Merge ~bullwinkle-team/ubuntu/+source/rocfft:bullwinkle/llvm-21/ubuntu/devel into ubuntu/+source/rocfft:ubuntu/devel

[Bruno Bernardo de Moura]

New upstream version 7.1.0

[Bruno Bernardo de Moura (bruno-bdmoura)]

Build in ppa: https://launchpad.net/~bruno-bdmoura/+archive/ubuntu/lp-2139240-rocfft

(~proposed and target archs)

[Andreas Hasenack (ahasenack)]

#TBD bug needs updating in d/changelog

[Andreas Hasenack (ahasenack)]

Question in line about bullwinkle.sources

[Andreas Hasenack (ahasenack)]

Just adding a comment because launchpad OOPSed in my previous two, because they included diff comments.

[Talha Can Havadar (tchavadar)]

Hello Andreas, I added these salsa-ci changes just to use salsa with our ppa during development they can indeed be dropped safely, Bruno can you drop the relevant commits and rebase?

[Talha Can Havadar (tchavadar)]

just forced with lease, salsa-ci related changes should be gone now

[Talha Can Havadar (tchavadar)]

Fixed the TBD in changelog as well

[Igor Luppi (igorluppi)]

Where are the inline comments?
src:hiprand was accepted, this one is finally ready to archive.

[Andreas Hasenack (ahasenack)]

Click on "show diff comments" comment text box.

[Andreas Hasenack (ahasenack)]

And then scroll... Yes, this UI is bad. In future PRs I'll refrain from doing that, and will just copy & paste the diff here in this box when I have a comment.

[Igor Luppi (igorluppi)]

Due to the fixup/rebase it's not working the 'show diff comments' :/

[Talha Can Havadar (tchavadar)]

I can see 2 inline comments on first revision in LP review. and they are addressed

they were about TBD and salsa-ci

[Andreas Hasenack (ahasenack)]

Recovering them here:

b) bullwinkle.sources
It's the first time I see something like this. I see the corresponding change in d/salsa-ci.yml, though. Is this a pattern for adding external repositories to salsa ci? Is this the way to do it? I was hoping for something in salsa-ci.yml directly, and not just a reference to a sources file elsewhere in the packaging. Perhaps even an add-apt-repository command.

[Andreas Hasenack (ahasenack)]

a) TBD in changelog
TBD needs updating

That was it, now checking updates.

[Andreas Hasenack (ahasenack)]

--- a/debian/control
+++ b/debian/control
@@ -36,7 +36,7 @@ Rules-Requires-Root: no

 Package: librocfft0
 Section: libs
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
 Multi-Arch: same
 XB-X-ROCm-GPU-Architecture: ${rocm:GPU-Architecture}
 Depends: ${misc:Depends}, ${shlibs:Depends}
@@ -53,7 +53,7 @@ Description: ROCm library for computing Fast Fourier Transforms - library

 Package: librocfft-dev
 Section: libdevel
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
 Depends: librocfft0 (= ${binary:Version}), ${misc:Depends}, ${shlibs:Depends}
 Recommends: libamdhip64-dev
 Suggests: librocfft-doc
@@ -70,7 +70,7 @@ Description: ROCm library for computing Fast Fourier Transforms - headers

 Package: librocfft0-tests
 Section: libdevel
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
 Build-Profiles: <!nocheck>
 Depends: librocfft0 (= ${binary:Version}), ${misc:Depends}, ${shlibs:Depends}
 Description: ROCm library for computing Fast Fourier Transforms - tests

ppc64el is being dropped, what is the impact?

review: Needs Information

[Talha Can Havadar (tchavadar)]

seems like no rdepends:

```
root@pretty-antelope:~# ./reverse-depends-source.sh rocfft
+ '[' -z rocfft ']'
+ SOURCE_PKG=rocfft
++ apt-cache showsrc rocfft
++ grep -m1 '^Binary:'
++ sed 's/^Binary: //'
++ tr , '\n'
++ tr -d ' '
+ BINARIES=$'librocfft0\nlibrocfft-dev\nlibrocfft0-tests\nlibrocfft-doc'
+ '[' -z $'librocfft0\nlibrocfft-dev\nlibrocfft0-tests\nlibrocfft-doc' ']'
+ for pkg in $BINARIES
+ echo '=== reverse-depends for: librocfft0 ==='
=== reverse-depends for: librocfft0 ===
+ reverse-depends -x -a ppc64el librocfft0
No reverse dependencies found
+ reverse-depends -a ppc64el -x -b librocfft0
No reverse dependencies found
+ echo ''

+ for pkg in $BINARIES
+ echo '=== reverse-depends for: librocfft-dev ==='
=== reverse-depends for: librocfft-dev ===
+ reverse-depends -x -a ppc64el librocfft-dev
No reverse dependencies found
+ reverse-depends -a ppc64el -x -b librocfft-dev
b'<p>Unknown package</p>'
+ echo ''

+ for pkg in $BINARIES
+ echo '=== reverse-depends for: librocfft0-tests ==='
=== reverse-depends for: librocfft0-tests ===
+ reverse-depends -x -a ppc64el librocfft0-tests
No reverse dependencies found
+ reverse-depends -a ppc64el -x -b librocfft0-tests
No reverse dependencies found
+ echo ''

+ for pkg in $BINARIES
+ echo '=== reverse-depends for: librocfft-doc ==='
=== reverse-depends for: librocfft-doc ===
+ reverse-depends -x -a ppc64el librocfft-doc
No reverse dependencies found
+ reverse-depends -a ppc64el -x -b librocfft-doc
No reverse dependencies found
+ echo ''

root@pretty-antelope:~# reverse-depends --arch ppc64el -x rocfft
b'<p>Unknown package</p>'
root@pretty-antelope:~# reverse-depends --arch ppc64el -x src:rocfft
No reverse dependencies found
```

[Andreas Hasenack (ahasenack)]

I see librocfft0 was removed[1] as requested by bug LP: #2134241, together with many other packages. Maybe the reverse dependencies were in that list as well.

But right now, the state is as you described, so +1.

1. https://launchpad.net/ubuntu/resolute/ppc64el/librocfft0

review: Approve

[Andreas Hasenack (ahasenack)]

Sponsored:

Uploading rocfft_7.1.0-0ubuntu1.dsc
Uploading rocfft_7.1.0.orig.tar.gz
Uploading rocfft_7.1.0-0ubuntu1.debian.tar.xz
Uploading rocfft_7.1.0-0ubuntu1_source.buildinfo
Uploading rocfft_7.1.0-0ubuntu1_source.changes

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
old mode 100755
new mode 100644
index eff670f..056a93f
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,8 +1,8 @@
-* @af-ayala @eng-flavio-teixeira @evetsso @feizheng10 @malcolmroberts
+* @af-ayala @eng-flavio-teixeira @evetsso @malcolmroberts @regan-amd
 # Documentation files
 docs/ @ROCm/rocm-documentation
 *.md @ROCm/rocm-documentation
 *.rst @ROCm/rocm-documentation
 .readthedocs.yaml @ROCm/rocm-documentation
 # Header directory for Doxygen documentation
-library/include/ @ROCm/rocm-documentation @af-ayala @eng-flavio-teixeira @evetsso @feizheng10 @malcolmroberts
+library/include/ @ROCm/rocm-documentation @af-ayala @eng-flavio-teixeira @evetsso @malcolmroberts @regan-amd
diff --git a/.jenkins/application.groovy b/.jenkins/application.groovy
deleted file mode 100644
index f57030b..0000000
--- a/.jenkins/application.groovy
+++ /dev/null
@@ -1,182 +0,0 @@
-#!/usr/bin/env groovy
-// This shared library is available at https://github.com/ROCmSoftwarePlatform/rocJENKINS/
-@Library('rocJenkins@pong') _
-
-// This is file for internal AMD use.
-// If you are interested in running your own Jenkins, please raise a github issue for assistance.
-
-import com.amd.project.*
-import com.amd.docker.*
-import java.nio.file.Path
-
-def runCI = 
-{
-    nodeDetails, jobName->
-
-    def prj  = new rocProject('rocFFT-internal', 'application')
-
-    prj.defaults.ccache = true
-    prj.timeout.compile = 600
-    prj.timeout.test = 600
-    prj.libraryDependencies = ['rocFFT', 'hipFFT']
-
-    // Define test architectures, optional rocm version argument is available
-    def nodes = new dockerNodes(nodeDetails, jobName, prj)
-
-    boolean formatCheck = false
-
-    def commonGroovy
-
-    def compileCommand =
-    {
-        platform, project->
-        def getDependenciesCommand = ""
-        if (project.installLibraryDependenciesFromCI)
-        {
-            project.libraryDependencies.each
-            { libraryName ->
-                getDependenciesCommand += auxiliary.getLibrary(libraryName, platform.jenkinsLabel, null, false)
-            }
-        } 
-
-        def command = """#!/usr/bin/env bash
-                         set -ex
-                         cd ${project.paths.project_build_prefix}
-                         ${getDependenciesCommand}
-                         git clone -b develop-2021 https://github.com/ROCmSoftwarePlatform/Gromacs.git
-                         cd Gromacs
-                         
-                         mkdir build_tmpi
-                         cd build_tmpi
-                         cmake -DCMAKE_HIP_ARCHITECTURES=gfx90a -DBUILD_SHARED_LIBS=ON -DGMX_BUILD_FOR_COVERAGE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DGMX_MPI=OFF -DGMX_GPU=hip -DGMX_OPENMP=ON -DGMX_SIMD=AVX2_256 -DREGRESSIONTEST_DOWNLOAD=OFF -DGMX_GPU_USE_VKFFT=OFF -DCMAKE_PREFIX_PATH=/opt/rocm -DCMAKE_INSTALL_PREFIX=../gromacs-install ..
-                         make
-                         make install
-                         cd ..
-
-                         mkdir build_mpi
-                         cd build_mpi
-                         cmake -DCMAKE_HIP_ARCHITECTURES=gfx908 -DBUILD_SHARED_LIBS=ON -DGMX_BUILD_FOR_COVERAGE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=mpicc -DCMAKE_CXX_COMPILER=mpic++ -DGMX_MPI=ON -DGMX_GPU=hip -DGMX_OPENMP=ON -DGMX_SIMD=AVX2_256 -DREGRESSIONTEST_DOWNLOAD=OFF -DGMX_GPU_USE_VKFFT=OFF -DCMAKE_PREFIX_PATH=/opt/rocm -DCMAKE_INSTALL_PREFIX=../gromacs-install ..
-                         make
-                         make install
-                         cd ..
-                      """
-        platform.runCommand(this, command)
-    }
-
-    def testCommand =
-    {
-        platform, project->
-        
-        def command = """#!/usr/bin/env bash
-                         set -ex
-                         cd ${project.paths.project_build_prefix}
-                         cd Gromacs
-
-                         source gromacs-install/bin/GMXRC
-                         gmx --version
-
-                         export LD_LIBRARY_PATH=\$LD_LIBRARY_PATH:/opt/rocm/lib
-                         echo \$LD_LIBRARY_PATH
-
-                         git clone https://github.com/jychang48/benchmark-gromacs.git
-                         cd benchmark-gromacs
-
-                         export GMX_MAXBACKUP=-1
-
-                         echo "* Threaded MPI ******************************************************************************************************"
-
-                         #ADH_DODEC
-                         cd adh_dodec
-                         tar zxf adh_dodec.tar.gz
-                         gmx --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntmpi 1 -ntomp 64 -noconfout -nb gpu -bonded gpu -pme gpu -v -gpu_id 0 -s topol.tpr -nstlist 100               # 1 GPU
-                         gmx --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntmpi 4 -ntomp 16 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 01 -s topol.tpr -nstlist 200      # 2 GPUs   
-                         gmx --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntmpi 4 -ntomp 16 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 0123 -s topol.tpr -nstlist 200    # 4 GPUs
-                         gmx --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntmpi 8 -ntomp 8 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 01234567 -s topol.tpr -nstlist 150 # 8 GPUs
-                         
-                         # STMV
-                         cd ..
-                         cd stmv/
-                         tar zxf stmv.tar.gz
-                         gmx --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntmpi 1 -ntomp 64 -noconfout -nb gpu -bonded gpu -pme gpu -v -gpu_id 0 -s topol.tpr -nstlist 200               # 1 GPU
-                         gmx --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntmpi 4 -ntomp 16 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 01 -s topol.tpr -nstlist 200      # 2 GPUs
-                         gmx --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntmpi 8 -ntomp 8 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 0123 -s topol.tpr -nstlist 400     # 4 GPUs
-                         gmx --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntmpi 8 -ntomp 8 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 01234567 -s topol.tpr -nstlist 400 # 8 GPUs
- 
-                         # CELLULOSE_NVE
-                         cd ..
-                         cd cellulose_nve/
-                         tar zxf cellulose_nve.tar.gz
-                         gmx --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntmpi 1 -ntomp 64 -noconfout -nb gpu -bonded gpu -pme gpu -v -gpu_id 0 -s topol.tpr -nstlist 100               # 1 GPU
-                         gmx --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntmpi 4 -ntomp 16 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 01 -s topol.tpr -nstlist 200      # 2 GPUs
-                         gmx --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntmpi 8 -ntomp 8 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 0123 -s topol.tpr -nstlist 200     # 4 GPUs
-                         gmx --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntmpi 8 -ntomp 8 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 01234567 -s topol.tpr -nstlist 200 # 8 GPUs
-
-                         echo "* MPI ***************************************************************************************************************" 
- 
-                         # ADH_DODEC
-                         cd ..
-                         cd adh_dodec/
-                         tar zxf adh_dodec.tar.gz
-                         mpirun -np 1 gmx_mpi --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntomp 64 -noconfout -nb gpu -bonded gpu -pme gpu -v -gpu_id 0 -s topol.tpr                # 1 GPU
-                         mpirun -np 4 gmx_mpi --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntomp 8 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 01 -s topol.tpr        # 2 GPUs
-                         mpirun -np 8 gmx_mpi --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntomp 6 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 0123 -s topol.tpr      # 4 GPUs
-                         mpirun -np 8 gmx_mpi --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntomp 6 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 01234567 -s topol.tpr  # 8 GPUs
- 
-                         # STMV
-                         cd ..
-                         cd stmv/
-                         tar zxf stmv.tar.gz
-                         mpirun -np 1 gmx_mpi --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntomp 64 -noconfout -nb gpu -bonded gpu -pme gpu -v -nstlist 400 -gpu_id 0 -s topol.tpr   # 1 GPU
-                         mpirun -np 4 gmx_mpi --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntomp 8 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 01 -s topol.tpr        # 2 GPUs
-                         mpirun -np 8 gmx_mpi --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntomp 8 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 0123 -s topol.tpr      # 4 GPUs
-                         mpirun -np 8 gmx_mpi --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntomp 8 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 01234567 -s topol.tpr  # 8 GPUs
- 
-                         # CELLULOSE_NVE
-                         cd ..
-                         cd cellulose_nve/
-                         tar zxf cellulose_nve.tar.gz
-                         mpirun -np 1 gmx_mpi --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntomp 64 -noconfout -nb gpu -bonded gpu -pme gpu -v -gpu_id 0 -s topol.tpr                # 1 GPU
-                         mpirun -np 4 gmx_mpi --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntomp 8 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 01 -s topol.tpr        # 2 GPUs
-                         mpirun -np 8 gmx_mpi --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntomp 6 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 0123 -s topol.tpr      # 4 GPUs
-                         mpirun -np 8 gmx_mpi --quiet mdrun -pin on -nsteps 100000 -resetstep 90000 -ntomp 8 -noconfout -nb gpu -bonded gpu -pme gpu -npme 1 -v -gpu_id 01234567 -s topol.tpr  # 8 GPUs
-                      """
-        platform.runCommand(this, command)
-    }
-
-    buildProject(prj, formatCheck, nodes.dockerArray, compileCommand, testCommand, null)
-}
-
-ci: { 
-    String urlJobName = auxiliary.getTopJobName(env.BUILD_URL)
-
-    def propertyList = ["compute-rocm-dkms-no-npi-hipclang":[pipelineTriggers([cron('0 1 * * 5')])]]
-    propertyList = auxiliary.appendPropertyList(propertyList)
-
-    def jobNameList = ["compute-rocm-dkms-no-npi-hipclang":([ubuntu20:['8gfx90a']])]
-    jobNameList = auxiliary.appendJobNameList(jobNameList)
-
-    propertyList.each 
-    {
-        jobName, property->
-        if (urlJobName == jobName)
-            properties(auxiliary.addCommonProperties(property))
-    }
-
-    jobNameList.each 
-    {
-        jobName, nodeDetails->
-        if (urlJobName == jobName)
-            stage(jobName) {
-                runCI(nodeDetails, jobName)
-            }
-    }
-
-    // For url job names that are not listed by the jobNameList i.e. compute-rocm-dkms-no-npi-1901
-    if(!jobNameList.keySet().contains(urlJobName))
-    {
-        properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * *')])]))
-        stage(urlJobName) {
-            runCI([ubuntu18:['8gfx90a']], urlJobName)
-        }
-    }
-}
diff --git a/.jenkins/common.groovy b/.jenkins/common.groovy
deleted file mode 100644
index fb1397c..0000000
--- a/.jenkins/common.groovy
+++ /dev/null
@@ -1,136 +0,0 @@
-// This file is for internal AMD use.
-// If you are interested in running your own Jenkins, please raise a github issue for assistance.
-
-def runCompileCommand(platform, project, jobName, boolean debug=false, boolean buildStatic=false, boolean buildMPI=false)
-{
-    project.paths.construct_build_prefix()
-
-    def getDependenciesCommand = ""
-    if (project.installLibraryDependenciesFromCI)
-    {
-        project.libraryDependencies.each
-        { libraryName ->
-            getDependenciesCommand += auxiliary.getLibrary(libraryName, platform.jenkinsLabel, null, false)
-        }
-    }
-
-    String clientArgs = '-DBUILD_CLIENTS_SAMPLES=ON -DBUILD_CLIENTS_TESTS=ON -DBUILD_CLIENTS_BENCH=ON'
-    String warningArgs = '-DWERROR=ON'
-    String buildTunerArgs = '-DROCFFT_BUILD_OFFLINE_TUNER=ON'
-    String buildTypeArg = debug ? '-DCMAKE_BUILD_TYPE=Debug -DROCFFT_DEVICE_FORCE_RELEASE=ON' : '-DCMAKE_BUILD_TYPE=Release'
-    String buildTypeDir = debug ? 'debug' : 'release'
-    String buildMPIArgs = buildMPI ? '-DCMAKE_PREFIX_PATH=/usr/local/openmpi -DROCFFT_MPI_ENABLE=ON' : ''
-    String staticArg = buildStatic ? '-DBUILD_SHARED_LIBS=off' : ''
-    String cmake = platform.jenkinsLabel.contains('centos') ? 'cmake3' : 'cmake'
-    //Set CI node's gfx arch as target if PR, otherwise use default targets of the library
-    String amdgpuTargets = env.BRANCH_NAME.startsWith('PR-') ? '-DAMDGPU_TARGETS=\$gfx_arch' : ''
-    String rtcBuildCache = "-DROCFFT_BUILD_KERNEL_CACHE_PATH=\$JENKINS_HOME_LOCAL/rocfft_build_cache.db"
-
-    def command = """#!/usr/bin/env bash
-                set -x
-                cd ${project.paths.project_build_prefix}
-                ${getDependenciesCommand}
-                set -e
-
-                mkdir -p build/${buildTypeDir} && cd build/${buildTypeDir}
-                ${auxiliary.gfxTargetParser()}
-                ${cmake} ${buildMPIArgs} -DCMAKE_CXX_COMPILER=/opt/rocm/bin/amdclang++ -DCMAKE_C_COMPILER=/opt/rocm/bin/amdclang ${buildTypeArg} ${clientArgs} ${warningArgs} ${buildTunerArgs} ${staticArg} ${amdgpuTargets} ${rtcBuildCache} ../..
-
-                make -j\$(nproc)
-                sudo make install
-            """
-    platform.runCommand(this, command)
-}
-
-
-def runCompileClientCommand(platform, project, jobName, boolean debug=false)
-{
-    project.paths.construct_build_prefix()
-
-    String clientArgs = '-DBUILD_CLIENTS_SAMPLES=ON -DBUILD_CLIENTS_TESTS=ON -DBUILD_CLIENTS_BENCH=ON'
-    String warningArgs = '-DWERROR=ON'
-    String cmake = platform.jenkinsLabel.contains('centos') ? 'cmake3' : 'cmake'
-    String amdgpuTargets = env.BRANCH_NAME.startsWith('PR-') ? '-DAMDGPU_TARGETS=\$gfx_arch' : ''
-    String buildTypeArgClients = debug ? '-DCMAKE_BUILD_TYPE=Debug' : '-DCMAKE_BUILD_TYPE=Release'
-    String cmakePrefixPathArg = "-DCMAKE_PREFIX_PATH=${project.paths.project_build_prefix}"
-
-    def command = """#!/usr/bin/env bash
-                set -ex
-                cd ${project.paths.project_build_prefix}/clients
-                mkdir -p build && cd build
-                ${cmake} -DCMAKE_CXX_COMPILER=/opt/rocm/bin/amdclang++ -DCMAKE_C_COMPILER=/opt/rocm/bin/amdclang ${buildTypeArgClients} ${clientArgs} ${warningArgs} ${cmakePrefixPathArg} ${amdgpuTargets} ../
-                make -j\$(nproc)
-            """
-    platform.runCommand(this, command)
-}
-
-def runTestCommand (platform, project, boolean debug=false, gfilter='', extraArgs='')
-{
-    String testBinaryName = 'rocfft-test'
-    String directory = debug ? 'debug' : 'release'
-
-    String gfilterArg = ''
-    if (gfilter)
-    {
-        gfilterArg = "--gtest_filter=${gfilter}"
-    }
-
-    def command = """#!/usr/bin/env bash
-                set -ex
-                cd ${project.paths.project_build_prefix}/build/${directory}/clients/staging
-                ROCM_PATH=/opt/rocm GTEST_LISTENER=NO_PASS_LINE_IN_LOG ./${testBinaryName} --precompile=rocfft-test-precompile.db ${gfilterArg} --gtest_color=yes --R 80 --nrand 10 ${extraArgs}
-            """
-    platform.runCommand(this, command)
-}
-
-def runPackageCommand(platform, project, jobName, boolean debug=false)
-{
-    String directory = debug ? 'debug' : 'release'
-    def packageHelper = platform.makePackage(platform.jenkinsLabel,"${project.paths.project_build_prefix}/build/${directory}",false)
-    platform.runCommand(this, packageHelper[0])
-    platform.archiveArtifacts(this, packageHelper[1])
-
-    //trim temp files
-    def command = """#!/usr/bin/env bash
-                     set -ex
-                     cd ${project.paths.project_build_prefix}/build/${directory}/
-                     rm -rf _CPack_Packages/
-                     find -name '*.o' -delete
-                  """
-    platform.runCommand(this, command)
-}
-
-def runSubsetBuildCommand(platform, project, jobName, genPattern, genSmall, genLarge, boolean onlyDouble)
-{
-    project.paths.construct_build_prefix()
-
-    // Don't build clients, since we're just testing if the library can build
-    String clientArgs = ''
-    String warningArgs = '-DWERROR=ON'
-    String buildTypeArg = '-DCMAKE_BUILD_TYPE=Release'
-    String buildTypeDir = 'release'
-
-    String genPatternArgs = "-DGENERATOR_PATTERN=${genPattern}"
-    String manualSmallArgs = (genSmall != null) ? "-DGENERATOR_MANUAL_SMALL_SIZE=${genSmall}" : ''
-    String manualLargeArgs = (genLarge != null) ? "-DGENERATOR_MANUAL_LARGE_SIZE=${genLarge}" : ''
-    String precisionArgs = onlyDouble ? '-DGENERATOR_PRECISION=double' : ''
-    String kernelArgs = "${genPatternArgs} ${manualSmallArgs} ${manualLargeArgs} ${precisionArgs}"
-
-    String cmake = platform.jenkinsLabel.contains('centos') ? 'cmake3' : 'cmake'
-    //Set CI node's gfx arch as target if PR, otherwise use default targets of the library
-    String amdgpuTargets = env.BRANCH_NAME.startsWith('PR-') ? '-DAMDGPU_TARGETS=\$gfx_arch' : ''
-    String rtcBuildCache = "-DROCFFT_BUILD_KERNEL_CACHE_PATH=\$JENKINS_HOME_LOCAL/rocfft_build_cache.db"
-
-    def command = """#!/usr/bin/env bash
-                set -ex
-
-                cd ${project.paths.project_build_prefix}
-                rm -rf build/${buildTypeDir}
-                mkdir -p build/${buildTypeDir} && cd build/${buildTypeDir}
-                ${auxiliary.gfxTargetParser()}
-                ${cmake} -DCMAKE_CXX_COMPILER=/opt/rocm/bin/amdclang++ -DCMAKE_C_COMPILER=/opt/rocm/bin/amdclang ${buildTypeArg} ${clientArgs} ${kernelArgs} ${warningArgs} ${amdgpuTargets} ${rtcBuildCache} ../..
-                make -j\$(nproc)
-            """
-    platform.runCommand(this, command)
-}
-return this
diff --git a/.jenkins/debug.groovy b/.jenkins/debug.groovy
deleted file mode 100644
index d0f903c..0000000
--- a/.jenkins/debug.groovy
+++ /dev/null
@@ -1,89 +0,0 @@
-#!/usr/bin/env groovy
-// This shared library is available at https://github.com/ROCmSoftwarePlatform/rocJENKINS/
-@Library('rocJenkins@pong') _
-
-// This is file for internal AMD use.
-// If you are interested in running your own Jenkins, please raise a github issue for assistance.
-
-import com.amd.project.*
-import com.amd.docker.*
-import java.nio.file.Path
-
-def runCI = 
-{
-    nodeDetails, jobName->
-
-    def prj  = new rocProject('rocFFT-internal', 'Debug')
-
-    prj.defaults.ccache = true
-    prj.timeout.compile = 600
-    prj.timeout.test = 600
-    prj.libraryDependencies = ['rocRAND','hipRAND']
-
-    // Define test architectures, optional rocm version argument is available
-    def nodes = new dockerNodes(nodeDetails, jobName, prj)
-
-    boolean formatCheck = false
-
-    def commonGroovy
-
-    def compileCommand =
-    {
-        platform, project->
-
-        commonGroovy = load "${project.paths.project_src_prefix}/.jenkins/common.groovy"
-        commonGroovy.runCompileCommand(platform, project, jobName, true)
-    }
-
-    def testCommand =
-    {
-        platform, project->
-
-        commonGroovy.runTestCommand(platform, project, true)
-    }
-
-    def packageCommand =
-    {
-        platform, project->
-
-        commonGroovy.runPackageCommand(platform, project, jobName, true)
-    }
-
-
-    buildProject(prj , formatCheck, nodes.dockerArray, compileCommand, testCommand, packageCommand)
-}
-
-ci: { 
-    String urlJobName = auxiliary.getTopJobName(env.BUILD_URL)
-
-    def propertyList = ["compute-rocm-dkms-no-npi-hipclang":[pipelineTriggers([cron('0 1 * * 0')])]]
-    propertyList = auxiliary.appendPropertyList(propertyList)
-
-    def jobNameList = ["compute-rocm-dkms-no-npi-hipclang":([ubuntu18:['gfx900']])]
-    jobNameList = auxiliary.appendJobNameList(jobNameList)
-
-    propertyList.each 
-    {
-        jobName, property->
-        if (urlJobName == jobName)
-            properties(auxiliary.addCommonProperties(property))
-    }
-
-    jobNameList.each 
-    {
-        jobName, nodeDetails->
-        if (urlJobName == jobName)
-            stage(jobName) {
-                runCI(nodeDetails, jobName)
-            }
-    }
-
-    // For url job names that are not listed by the jobNameList i.e. compute-rocm-dkms-no-npi-1901
-    if(!jobNameList.keySet().contains(urlJobName))
-    {
-        properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * *')])]))
-        stage(urlJobName) {
-            runCI([ubuntu16:['any']], urlJobName)
-        }
-    }
-}
diff --git a/.jenkins/extended.groovy b/.jenkins/extended.groovy
deleted file mode 100644
index ee508db..0000000
--- a/.jenkins/extended.groovy
+++ /dev/null
@@ -1,120 +0,0 @@
-#!/usr/bin/env groovy
-// This shared library is available at https://github.com/ROCmSoftwarePlatform/rocJENKINS/
-@Library('rocJenkins@pong') _
-
-// This is file for internal AMD use.
-// If you are interested in running your own Jenkins, please raise a github issue for assistance.
-
-import com.amd.project.*
-import com.amd.docker.*
-import java.nio.file.Path
-
-def runBitwiseReproTest (platform, project, boolean debug=false, gfilter='', reprodb='', int repeat=1)
-{
-    String testBinaryName = 'rocfft-test'
-    String directory = debug ? 'debug' : 'release'
-
-    String gfilterArg = ''
-    if (gfilter)
-    {
-        gfilterArg = "--gtest_filter=${gfilter}"
-    }
-
-    String reproDbArg = ''
-    if (reprodb)
-    {
-        reproDbArg = "--repro-db=${reprodb}"
-    }    
-
-    String repeatArg = ''
-    if (repeat > 1)
-    {
-        repeatArg = "--gtest_repeat=${repeat}"
-    }
-
-    def command = """#!/usr/bin/env bash
-                set -ex
-                cd ${project.paths.project_build_prefix}/build/${directory}/clients/staging
-                ROCM_PATH=/opt/rocm GTEST_LISTENER=NO_PASS_LINE_IN_LOG ./${testBinaryName} --precompile=rocfft-test-precompile.db ${gfilterArg} ${reproDbArg} ${repeatArg} --gtest_color=yes --R 80 --nrand 10
-            """
-    platform.runCommand(this, command)
-}
-
-def runCI = 
-{
-    nodeDetails, jobName->
-
-    def prj  = new rocProject('rocFFT-internal', 'Extended')
-
-    prj.defaults.ccache = true
-    prj.timeout.compile = 600
-    prj.timeout.test = 600
-    prj.libraryDependencies = ['rocRAND','hipRAND']
-
-    // Define test architectures, optional rocm version argument is available
-    def nodes = new dockerNodes(nodeDetails, jobName, prj)
-
-    boolean formatCheck = false
-
-    def commonGroovy
-
-    def compileCommand =
-    {
-        platform, project->
-
-        commonGroovy = load "${project.paths.project_src_prefix}/.jenkins/common.groovy"
-        commonGroovy.runCompileCommand(platform, project, jobName)
-        commonGroovy.runCompileClientCommand(platform, project, jobName, false)
-    }
-
-    def testCommand =
-    {
-        platform, project->          
-
-        runBitwiseReproTest(platform, project, false, "*pow2_1D/bitwise_repro_test*", 'bitwise_repro.db', 2)
-    }
-
-    def packageCommand =
-    {
-        platform, project->
-        
-        commonGroovy.runPackageCommand(platform, project, jobName)
-    }
-
-    buildProject(prj, formatCheck, nodes.dockerArray, compileCommand, testCommand, packageCommand)
-}
-
-ci: { 
-    String urlJobName = auxiliary.getTopJobName(env.BUILD_URL)
-
-    def propertyList = ["compute-rocm-dkms-no-npi-hipclang":[pipelineTriggers([cron('0 1 * * 0')])]]
-    propertyList = auxiliary.appendPropertyList(propertyList)
-
-    def jobNameList = ["compute-rocm-dkms-no-npi-hipclang":([ubuntu18:['gfx900'],centos7:['gfx906'],centos8:['gfx906'],sles15sp1:['gfx908']])]
-    jobNameList = auxiliary.appendJobNameList(jobNameList)
-
-    propertyList.each 
-    {
-        jobName, property->
-        if (urlJobName == jobName)
-            properties(auxiliary.addCommonProperties(property))
-    }
-
-    jobNameList.each 
-    {
-        jobName, nodeDetails->
-        if (urlJobName == jobName)
-            stage(jobName) {
-                runCI(nodeDetails, jobName)
-            }
-    }
-
-    // For url job names that are not listed by the jobNameList i.e. compute-rocm-dkms-no-npi-1901
-    if(!jobNameList.keySet().contains(urlJobName))
-    {
-        properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * *')])]))
-        stage(urlJobName) {
-            runCI([ubuntu18:['gfx906']], urlJobName)
-        }
-    }
-}
diff --git a/.jenkins/multigpu.groovy b/.jenkins/multigpu.groovy
deleted file mode 100644
index 68e625f..0000000
--- a/.jenkins/multigpu.groovy
+++ /dev/null
@@ -1,93 +0,0 @@
-#!/usr/bin/env groovy
-// This shared library is available at https://github.com/ROCmSoftwarePlatform/rocJENKINS/
-@Library('rocJenkins@pong') _
-
-// This is file for internal AMD use.
-// If you are interested in running your own Jenkins, please raise a github issue for assistance.
-
-import com.amd.project.*
-import com.amd.docker.*
-import java.nio.file.Path
-
-def runCI = 
-{
-    nodeDetails, jobName->
-
-    def prj  = new rocProject('rocFFT-internal', 'multigpu')
-
-    prj.defaults.ccache = true
-    prj.timeout.compile = 600
-    prj.timeout.test = 600
-    prj.libraryDependencies = ['rocRAND','hipRAND']
-
-    // Define test architectures, optional rocm version argument is available
-    def nodes = new dockerNodes(nodeDetails, jobName, prj)
-
-    boolean formatCheck = false
-
-    def commonGroovy
-
-    def compileCommand =
-    {
-        platform, project->
-
-        commonGroovy = load "${project.paths.project_src_prefix}/.jenkins/common.groovy"
-	    // build with MPI enabled
-        commonGroovy.runCompileCommand(platform, project, jobName, false, false, true)
-        commonGroovy.runCompileClientCommand(platform, project, jobName, false)
-    }
-
-    def testCommand =
-    {
-        platform, project->
-
-	    //run single-process multi-GPU tests
-        commonGroovy.runTestCommand(platform, project, false, "*multi_gpu*")
-	    // run MPI tests across 4 ranks
-        commonGroovy.runTestCommand(platform, project, false, "*multi_gpu*", '--mp_lib mpi --mp_ranks 4 --mp_launch "/usr/local/openmpi/bin/mpirun --np 4 ./rocfft_mpi_worker"')
-    }
-
-    def packageCommand =
-    {
-        platform, project->
-
-	    // don't package anything - we're not distributing MPI-enabled rocFFT so we don't want to expose any MPI-enabled packages anywhere that other builds can mistakenly pick up
-    }
-
-    buildProject(prj, formatCheck, nodes.dockerArray, compileCommand, testCommand, packageCommand)
-}
-
-ci: { 
-    String urlJobName = auxiliary.getTopJobName(env.BUILD_URL)
-
-    def propertyList = ["main":[pipelineTriggers([cron('0 1 * * 0')])]]
-    propertyList = auxiliary.appendPropertyList(propertyList)
-
-    def jobNameList = ["main":([ubuntu20:['8gfx90a']])]
-    jobNameList = auxiliary.appendJobNameList(jobNameList)
-
-    propertyList.each 
-    {
-        jobName, property->
-        if (urlJobName == jobName)
-            properties(auxiliary.addCommonProperties(property))
-    }
-
-    jobNameList.each 
-    {
-        jobName, nodeDetails->
-        if (urlJobName == jobName)
-            stage(jobName) {
-                runCI(nodeDetails, jobName)
-            }
-    }
-
-    // For url job names that are not listed by the jobNameList i.e. compute-rocm-dkms-no-npi-1901
-    if(!jobNameList.keySet().contains(urlJobName))
-    {
-        properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * *')])]))
-        stage(urlJobName) {
-            runCI([ubuntu20:['8gfx90a']], urlJobName)
-        }
-    }
-}
diff --git a/.jenkins/performance.groovy b/.jenkins/performance.groovy
deleted file mode 100644
index d488f59..0000000
--- a/.jenkins/performance.groovy
+++ /dev/null
@@ -1,231 +0,0 @@
-#!/usr/bin/env groovy
-// This shared library is available at https://github.com/ROCmSoftwarePlatform/rocJENKINS/
-@Library('rocJenkins@pong') _
-
-// This is file for internal AMD use.
-// If you are interested in running your own Jenkins, please raise a github issue for assistance.
-
-import com.amd.project.*
-import com.amd.docker.*
-import java.nio.file.Path
-
-def runCompileCommand(platform, project, jobName, boolean debug=false, boolean buildStatic=false)
-{
-    def reference = (env.BRANCH_NAME ==~ /PR-\d+/) ? 'develop' : 'master'
-
-    project.paths.construct_build_prefix()
-
-    def getDependenciesCommand = ""
-    if (project.installLibraryDependenciesFromCI)
-    {
-        project.libraryDependencies.each
-        { libraryName ->
-            getDependenciesCommand += auxiliary.getLibrary(libraryName, platform.jenkinsLabel, null, false)
-        }
-    }
-
-    dir("${project.paths.project_build_prefix}/ref-repo") {
-       git branch: "${reference}", url: 'https://github.com/ROCmSoftwarePlatform/rocFFT.git'
-    }
-
-    String clientArgs = '-DBUILD_CLIENTS_SAMPLES=ON -DBUILD_CLIENTS_TESTS=ON -DBUILD_CLIENTS_BENCH=ON'
-    String noclientArgs = '-DBUILD_CLIENTS_SAMPLES=OFF -DBUILD_CLIENTS_TESTS=OFF -DBUILD_CLIENTS_BENCH=OFF'
-    String warningArgs = '-DWERROR=ON'
-    String buildTypeArg = debug ? '-DCMAKE_BUILD_TYPE=Debug -DROCFFT_DEVICE_FORCE_RELEASE=ON' : '-DCMAKE_BUILD_TYPE=Release'
-    String buildTypeDir = debug ? 'debug' : 'release'
-    String rtcBuildCache = "-DROCFFT_BUILD_KERNEL_CACHE_PATH=\$JENKINS_HOME_LOCAL/rocfft_build_cache.db"
-    String cmake = platform.jenkinsLabel.contains('centos') ? 'cmake3' : 'cmake'
-
-    def command = """#!/usr/bin/env bash
-                set -x
-                cd ${project.paths.project_build_prefix}
-                ${getDependenciesCommand}
-                set -e
-                mkdir -p build/${buildTypeDir} && pushd build/${buildTypeDir}
-                ${auxiliary.gfxTargetParser()}
-                ${cmake} -DCMAKE_CXX_COMPILER=/opt/rocm/bin/amdclang++ -DCMAKE_C_COMPILER=/opt/rocm/bin/amdclang -DAMDGPU_TARGETS=\$gfx_arch ${buildTypeArg} ${clientArgs} ${warningArgs} ${rtcBuildCache} ../..
-                make -j\$(nproc)
-                popd
-                cd ref-repo
-                mkdir -p build/${buildTypeDir} && pushd build/${buildTypeDir}
-                ${auxiliary.gfxTargetParser()}
-                ${cmake} -DCMAKE_CXX_COMPILER=/opt/rocm/bin/amdclang++ -DCMAKE_C_COMPILER=/opt/rocm/bin/amdclang -DAMDGPU_TARGETS=\$gfx_arch ${buildTypeArg} ${noclientArgs} ${warningArgs} ${rtcBuildCache} ../..
-                make -j\$(nproc)
-            """
-    platform.runCommand(this, command)
-}
-
-def runTestCommand (platform, project, boolean debug=false)
-{
-    String sudo = auxiliary.sudo(platform.jenkinsLabel)
-    String directory = debug ? 'debug' : 'release'
-
-    def dataTypes = ['single', 'double']
-    for (def dataType in dataTypes)
-    {
-        def command = """#!/usr/bin/env bash
-                    set -ex
-                    pwd
-                    cd ${project.paths.project_build_prefix}
-		    export ROCFFT_RTC_CACHE_PATH="\$JENKINS_HOME_LOCAL/rocfft_build_cache.db"
-                    ./scripts/perf/rocfft-perf run --bench ./build/${directory}/clients/staging/dyna-rocfft-bench --lib ./ref-repo/build/${directory}/library/src/librocfft.so --lib ./build/${directory}/library/src/librocfft.so --out ./${dataType}_ref --out ./${dataType}_change --device 0 --precision ${dataType} --suite benchmarks
-                    ls ${dataType}_change
-                    ls ${dataType}_ref
-                    mkdir ${dataType}_results
-                    ./scripts/perf/rocfft-perf post ./${dataType}_results ./${dataType}_ref ./${dataType}_change
-                    ls ${dataType}_change/*.mdat
-                    ./scripts/perf/rocfft-perf html ./${dataType}_results ./${dataType}_ref ./${dataType}_change
-                    mv ${dataType}_results/figs.html ${dataType}_results/figs_${platform.gpu}.html
-                """
-         platform.runCommand(this, command)
-
-         archiveArtifacts "${project.paths.project_build_prefix}/${dataType}_results/*.html"
-         publishHTML([allowMissing: false,
-                    alwaysLinkToLastBuild: false,
-                    keepAll: false,
-                    reportDir: "${project.paths.project_build_prefix}/${dataType}_results",
-                    reportFiles: "figs_${platform.gpu}.html",
-                    reportName: "${dataType}-precision-${platform.gpu}",
-                    reportTitles: "${dataType}-precision-${platform.gpu}"])
-    }
-
-
-    withCredentials([gitUsernamePassword(credentialsId: 'GitHub-ROCmMathLibrariesBot-Token', gitToolName: 'git-tool')])
-    {
-        platform.runCommand(
-            this,
-            """
-            cd ${project.paths.build_prefix}
-            git clone https://github.com/ROCmSoftwarePlatform/rocPTS.git -b release/rocpts-rel-1.2.0
-            cd rocPTS
-            python3 -m pip install build
-            python3 -m build
-            python3 -m pip install .
-            """
-        )
-    }
-    writeFile(
-        file: project.paths.project_build_prefix + "/record_pts.py",
-        text: libraryResource("com/amd/scripts/record_pts.py"))
-    def setupBranch = env.CHANGE_ID ? "git branch \$BRANCH_NAME" : ""
-    def command = """#!/usr/bin/env bash
-    set -ex
-    cd ${project.paths.project_build_prefix}
-    ${setupBranch}
-    git checkout \$BRANCH_NAME
-    benchmark_folder=rocFFT_Benchmark_Dataset_\$(date +%Y%m%d)
-    mkdir -p \${benchmark_folder}/all_change \${benchmark_folder}/all_ref
-    cp -uf ./*_change/* \${benchmark_folder}/all_change
-    cp -uf ./*_ref/* \${benchmark_folder}/all_ref
-    python3 ./record_pts.py \
-        --dataset-path \$PWD/\${benchmark_folder} \
-        --reference-dataset all_ref \
-        --new-dataset all_change \
-        --new-build . \
-        --reference-build ./ref-repo\
-        -v 5.5 \
-        -l pts_rocfft_benchmark_data-v1.0.0
-    """
-    withCredentials([usernamePassword(credentialsId: 'PTS_API_ID_KEY_PROD', usernameVariable: 'PTS_API_ID', passwordVariable: 'PTS_API_KEY')])
-    {
-        platform.runCommand(this, command)
-    }
-}
-
-def runCI =
-{
-    nodeDetails, jobName->
-
-    def prj  = new rocProject('rocFFT-internal', 'Performance')
-
-    prj.defaults.ccache = true
-    prj.timeout.compile = 600
-    prj.timeout.test = 600
-    prj.libraryDependencies = ['rocRAND','hipRAND']
-
-    // Define test architectures, optional rocm version argument is available
-    def nodes = new dockerNodes(nodeDetails, jobName, prj)
-
-    boolean formatCheck = false
-
-    def commonGroovy
-    def gpus = []
-    def dataTypes = ['single', 'double']
-
-    def compileCommand =
-    {
-        platform, project->
-
-        gpus.add(platform.gpu)
-        commonGroovy = load "${project.paths.project_src_prefix}/.jenkins/common.groovy"
-        runCompileCommand(platform, project, jobName)
-    }
-
-    def testCommand =
-    {
-        platform, project->
-
-        runTestCommand(platform, project)
-    }
-
-    buildProject(prj, formatCheck, nodes.dockerArray, compileCommand, testCommand, null)
-    def commentString = "Performance reports: \n" + "Commit hashes: \n"
-    for (parentHash in prj.gitParentHashes) {
-         commentString += "${parentHash} \n"
-    }
-    for (gpu in gpus) {
-        for (dataType in dataTypes) {
-            commentString += "[${gpu} ${dataType} report](${JOB_URL}/${dataType}-precision-${gpu})\n"
-        }
-    }
-
-    if (env.BRANCH_NAME ==~ /PR-\d+/)
-    {
-        boolean commentExists = false
-        for (prComment in pullRequest.comments) {
-            if (prComment.body.contains("Performance reports:"))
-            {
-                commentExists = true
-                prComment.body = commentString
-            }
-        }
-        if (!commentExists) {
-            def comment = pullRequest.comment(commentString)
-        }
-    }
-}
-
-ci: {
-    String urlJobName = auxiliary.getTopJobName(env.BUILD_URL)
-
-    def propertyList = ["compute-rocm-dkms-no-npi-hipclang":[pipelineTriggers([cron('0 1 * * 0')])]]
-    propertyList = auxiliary.appendPropertyList(propertyList)
-
-    def jobNameList = ["compute-rocm-dkms-no-npi-hipclang":([ubuntu18:['gfx900','gfx906']])]
-    jobNameList = auxiliary.appendJobNameList(jobNameList)
-
-    propertyList.each
-    {
-        jobName, property->
-        if (urlJobName == jobName)
-            properties(auxiliary.addCommonProperties(property))
-    }
-
-    jobNameList.each
-    {
-        jobName, nodeDetails->
-        if (urlJobName == jobName)
-            stage(jobName) {
-                runCI(nodeDetails, jobName)
-            }
-    }
-
-    // For url job names that are not listed by the jobNameList i.e. compute-rocm-dkms-no-npi-1901
-    if(!jobNameList.keySet().contains(urlJobName))
-    {
-        properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * *')])]))
-        stage(urlJobName) {
-            runCI([ubuntu18:['gfx906']], urlJobName)
-        }
-    }
-}
diff --git a/.jenkins/staticanalysis.groovy b/.jenkins/staticanalysis.groovy
deleted file mode 100644
index b516520..0000000
--- a/.jenkins/staticanalysis.groovy
+++ /dev/null
@@ -1,110 +0,0 @@
-#!/usr/bin/env groovy
-// This shared library is available at https://github.com/ROCmSoftwarePlatform/rocJENKINS/
-@Library('rocJenkins@pong') _
-
-// This is file for internal AMD use.
-// If you are interested in running your own Jenkins, please raise a github issue for assistance.
-
-import com.amd.project.*
-import com.amd.docker.*
-import java.nio.file.Path
-
-def runCompileCommand(platform, project, jobName, boolean debug=false)
-{
-    project.paths.construct_build_prefix()
-
-    def yapfCommand = """#!/usr/bin/env bash
-                         set -x
-                         cd ${project.paths.project_build_prefix}
-                         yapf --version
-                         find . -iname '*.py' \
-                         | grep -v 'build/'  \
-                         | xargs -n 1 -P 1 -I{} -t sh -c 'yapf --style pep8 {} | diff - {}'
-                      """
-
-    platform.runCommand(this, yapfCommand)
-}
-
-def runCI =
-{
-    nodeDetails, jobName->
-
-    def prj  = new rocProject('rocFFT-internal', 'StaticAnalysis')
-    prj.libraryDependencies = ['rocRAND','hipRAND']
-
-    // Define test architectures, optional rocm version argument is available
-    def nodes = new dockerNodes(nodeDetails, jobName, prj)
-
-    boolean formatCheck = true
-    boolean staticAnalysis = true
-
-    def compileCommand =
-    {
-        platform, project->
-
-        runCompileCommand(platform, project, jobName, false)
-    }
-
-    buildProject(prj , formatCheck, nodes.dockerArray, compileCommand, null, null, staticAnalysis)
-
-
-    def kernelSubsetPrj  = new rocProject('rocFFT-internal', 'BuildKernelSubset')
-
-    def nodesForPrj2 = new dockerNodes(nodeDetails, jobName, kernelSubsetPrj)
-
-    def commonGroovy
-
-    def compileSubsetCommand =
-    {
-        platform, project->
-
-        commonGroovy = load "${project.paths.project_src_prefix}/.jenkins/common.groovy"
-
-        // build pattern pow2,pow7 no manual small and large, dp only
-        commonGroovy.runSubsetBuildCommand(platform, project, jobName, 'pow2,pow7', null, null, true)
-
-        // build large sizes, dp only
-        commonGroovy.runSubsetBuildCommand(platform, project, jobName, 'large', null, null, true)
-
-        // build 2D sizes, dp only
-        commonGroovy.runSubsetBuildCommand(platform, project, jobName, '2D', null, null, true)
-
-        // put an extra unsupported size(10) in manual large to see if it will be filtered correctly
-        commonGroovy.runSubsetBuildCommand(platform, project, jobName, 'none', null, '10,50,100,200,336', true)
-
-        // put an extra unsupported size(23) in manual small to see if it will be filtered correctly
-        commonGroovy.runSubsetBuildCommand(platform, project, jobName, 'none', '23,1024', '10,50,100,200,336', true)
-
-        // all the manual sizes are not supported
-        //commonGroovy.runSubsetBuildCommand(platform, project, jobName, 'none', '23', '10', true)
-    }
-
-    buildProject(kernelSubsetPrj , formatCheck, nodesForPrj2.dockerArray, compileSubsetCommand, null, null)
-}
-
-ci: {
-    String urlJobName = auxiliary.getTopJobName(env.BUILD_URL)
-
-    def propertyList = ["compute-rocm-dkms-no-npi-hipclang":[pipelineTriggers([cron('0 1 * * 6')])],
-                        "rocm-docker":[]]
-    propertyList = auxiliary.appendPropertyList(propertyList)
-
-    def jobNameList = ["compute-rocm-dkms-no-npi-hipclang":[]]
-    jobNameList = auxiliary.appendJobNameList(jobNameList)
-
-    propertyList.each
-    {
-        jobName, property->
-        if (urlJobName == jobName)
-            properties(auxiliary.addCommonProperties(property))
-    }
-
-    jobNameList.each
-    {
-        jobName, nodeDetails->
-        if (urlJobName == jobName)
-            stage(jobName) {
-                runCI(nodeDetails, jobName)
-            }
-    }
-}
diff --git a/.jenkins/staticlibrary.groovy b/.jenkins/staticlibrary.groovy
deleted file mode 100644
index dcc8dd5..0000000
--- a/.jenkins/staticlibrary.groovy
+++ /dev/null
@@ -1,88 +0,0 @@
-#!/usr/bin/env groovy
-// This shared library is available at https://github.com/ROCmSoftwarePlatform/rocJENKINS/
-@Library('rocJenkins@pong') _
-
-// This is file for internal AMD use.
-// If you are interested in running your own Jenkins, please raise a github issue for assistance.
-
-import com.amd.project.*
-import com.amd.docker.*
-import java.nio.file.Path
-
-def runCI = 
-{
-    nodeDetails, jobName->
-
-    def prj  = new rocProject('rocFFT-internal', 'StaticLibrary')
-
-    prj.defaults.ccache = true
-    prj.timeout.compile = 600
-    prj.timeout.test = 600
-    prj.libraryDependencies = ['rocRAND','hipRAND']
-
-    // Define test architectures, optional rocm version argument is available
-    def nodes = new dockerNodes(nodeDetails, jobName, prj)
-
-    boolean formatCheck = false
-
-    def commonGroovy
-
-    def compileCommand =
-    {
-        platform, project->
-
-        commonGroovy = load "${project.paths.project_src_prefix}/.jenkins/common.groovy"
-        commonGroovy.runCompileCommand(platform, project, jobName, false, true)
-    }
-
-    def testCommand =
-    {
-        platform, project->
-
-        commonGroovy.runTestCommand(platform, project)
-    }
-
-    def packageCommand =
-    {
-        platform, project->
-        
-        commonGroovy.runPackageCommand(platform, project, jobName)
-    }
-
-    buildProject(prj, formatCheck, nodes.dockerArray, compileCommand, testCommand, packageCommand)
-}
-
-ci: { 
-    String urlJobName = auxiliary.getTopJobName(env.BUILD_URL)
-
-    def propertyList = ["compute-rocm-dkms-no-npi-hipclang":[pipelineTriggers([cron('0 1 * * 0')])]]
-    propertyList = auxiliary.appendPropertyList(propertyList)
-
-    def jobNameList = ["compute-rocm-dkms-no-npi-hipclang":([ubuntu16:['gfx900']])]
-    jobNameList = auxiliary.appendJobNameList(jobNameList)
-
-    propertyList.each 
-    {
-        jobName, property->
-        if (urlJobName == jobName)
-            properties(auxiliary.addCommonProperties(property))
-    }
-
-    jobNameList.each 
-    {
-        jobName, nodeDetails->
-        if (urlJobName == jobName)
-            stage(jobName) {
-                runCI(nodeDetails, jobName)
-            }
-    }
-
-    // For url job names that are not listed by the jobNameList i.e. compute-rocm-dkms-no-npi-1901
-    if(!jobNameList.keySet().contains(urlJobName))
-    {
-        properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * *')])]))
-        stage(urlJobName) {
-            runCI([ubuntu16:['gfx906']], urlJobName)
-        }
-    }
-}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5c4bc51..659b4c7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,47 @@
 Documentation for rocFFT is available at
 [https://rocm.docs.amd.com/projects/rocFFT/en/latest/](https://rocm.docs.amd.com/projects/rocFFT/en/latest/).
 
+## rocFFT 1.0.35 for ROCM 7.1.0
+
+### Optimized
+
+* Implemented single-kernel plans for some 2D problem sizes, on devices with at least 160KiB of LDS.
+* Improved performance of unit-strided, complex-interleaved, forward/inverse FFTs for lengths:
+  - (64,64,128)
+  - (64,64,52)
+  - (60,60,60)
+  - (32,32,128)
+  - (32,32,64)
+  - (64,32,128)
+* Improved performance of 3D MPI pencil decompositions by using sub-communicators for global transpose operations.
+
+## rocFFT 1.0.34 for ROCm 7.0.0
+
+### Added
+
+* Added gfx950 support.
+
+### Removed
+
+* Removed rocfft-rider legacy compatibility from clients
+* Removed support for the gfx940 and gfx941 targets from the client programs.
+
+### Optimized
+
+* Removed unnecessary HIP event/stream allocation and synchronization during MPI transforms.
+* Implemented single-precision 1D kernels for lengths:
+  - 4704
+  - 5488
+  - 6144
+  - 6561
+  - 8192
+* Implemented single-kernel plans for some large 1D problem sizes, on devices with at least 160KiB of LDS.
+
+### Resolved issues
+
+* Fixed kernel faults on multi-device transforms that gather to a single device, when the input/output bricks are not 
+  contiguous.
+
 ## rocFFT 1.0.32 for ROCm 6.4.0
 
 ### Changed
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 75e5c36..c724aff 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,5 @@
 # #############################################################################
-# Copyright (C) 2016 - 2023 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright (C) 2016 - 2025 Advanced Micro Devices, Inc. All rights reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -52,34 +52,24 @@ project( rocfft LANGUAGES CXX C )
 # This finds the rocm-cmake project, and installs it if not found
 # rocm-cmake contains common cmake code for rocm projects to help setup and install
 set( PROJECT_EXTERN_DIR ${CMAKE_CURRENT_BINARY_DIR}/extern )
-find_package( ROCM 0.7.3 CONFIG QUIET PATHS ${ROCM_PATH} /opt/rocm )
-if( NOT ROCM_FOUND )
-  set( rocm_cmake_tag "master" CACHE STRING "rocm-cmake tag to download" )
-  file( DOWNLOAD https://github.com/RadeonOpenCompute/rocm-cmake/archive/${rocm_cmake_tag}.zip
-      ${PROJECT_EXTERN_DIR}/rocm-cmake-${rocm_cmake_tag}.zip STATUS status LOG log)
-
-  list(GET status 0 status_code)
-  list(GET status 1 status_string)
-
-  if(NOT status_code EQUAL 0)
-    message(FATAL_ERROR "error: downloading
-    'https://github.com/RadeonOpenCompute/rocm-cmake/archive/${rocm_cmake_tag}.zip' failed
-    status_code: ${status_code}
-    status_string: ${status_string}
-    log: ${log}
-    ")
-  endif()
+find_package( ROCmCMakeBuildTools PATHS ${ROCM_PATH} /opt/rocm )
+if( NOT ROCmCMakeBuildTools_FOUND )
+  include( FetchContent )
+
+  FetchContent_Declare( rocm_cmake_local
+    GIT_REPOSITORY https://github.com/ROCm/rocm-cmake
+    GIT_TAG rocm-6.4.1
+    GIT_SHALLOW ON
+  )
 
-  message(STATUS "downloading... done")
+  FetchContent_MakeAvailable( rocm_cmake_local )
 
-  execute_process( COMMAND ${CMAKE_COMMAND} -E tar xzvf ${PROJECT_EXTERN_DIR}/rocm-cmake-${rocm_cmake_tag}.zip
-    WORKING_DIRECTORY ${PROJECT_EXTERN_DIR} )
   execute_process( COMMAND ${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX=${PROJECT_EXTERN_DIR}/rocm-cmake .
-    WORKING_DIRECTORY ${PROJECT_EXTERN_DIR}/rocm-cmake-${rocm_cmake_tag} )
-  execute_process( COMMAND ${CMAKE_COMMAND} --build rocm-cmake-${rocm_cmake_tag} --target install
-    WORKING_DIRECTORY ${PROJECT_EXTERN_DIR})
+    WORKING_DIRECTORY ${rocm_cmake_local_SOURCE_DIR} )
+  execute_process( COMMAND ${CMAKE_COMMAND} --build ${rocm_cmake_local_SOURCE_DIR} --target install
+    WORKING_DIRECTORY ${rocm_cmake_local_SOURCE_DIR} )
 
-  find_package( ROCM 0.7.3 REQUIRED CONFIG PATHS ${PROJECT_EXTERN_DIR}/rocm-cmake )
+  find_package( ROCmCMakeBuildTools REQUIRED CONFIG PATHS ${PROJECT_EXTERN_DIR}/rocm-cmake )
 endif( )
 include( ROCMSetupVersion )
 include( ROCMCreatePackage )
@@ -90,8 +80,12 @@ include( ROCMCheckTargetIds )
 include( ROCMClients )
 include( ROCMHeaderWrapper )
 
+if( ROCM_PATH )
+  list( APPEND CMAKE_BUILD_RPATH ${ROCM_PATH}/lib )
+endif()
+
 # Using standardized versioning from rocm-cmake
-set ( VERSION_STRING "1.0.32" )
+set ( VERSION_STRING "1.0.35" )
 rocm_setup_version( VERSION ${VERSION_STRING} )
 
 # Append our library helper cmake path and the cmake path for hip (for
@@ -119,25 +113,10 @@ option(ROCFFT_BUILD_OFFLINE_TUNER "Build with offline tuner executable rocfft_of
 # Provide ability to disable hipRAND dependency
 option(USE_HIPRAND "Use hipRAND to provide device-side input generation" ON)
 
-if( USE_HIPRAND )
-  add_compile_definitions(USE_HIPRAND)
-endif( )
-
 # Split up function pool compilation across N files to parallelize its build
 set(ROCFFT_FUNCTION_POOL_N 8 CACHE STRING "Number of files to split function_pool into for compilation")
 
-# FOR HANDLING ENABLE/DISABLE OPTIONAL BACKWARD COMPATIBILITY for FILE/FOLDER REORG
-option(BUILD_FILE_REORG_BACKWARD_COMPATIBILITY "Build with file/folder reorg with backward compatibility enabled" OFF)
-if(BUILD_FILE_REORG_BACKWARD_COMPATIBILITY AND NOT WIN32)
-  rocm_wrap_header_dir(
-    ${CMAKE_SOURCE_DIR}/library/include
-    PATTERNS "*.h"
-    GUARDS SYMLINK WRAPPER
-    WRAPPER_LOCATIONS ${CMAKE_INSTALL_INCLUDEDIR}
-  )
-endif()
-
-set( WARNING_FLAGS -Wall -Wno-unused-function -Wimplicit-fallthrough -Wunreachable-code -Wsign-compare )
+set( WARNING_FLAGS -Wall -Wno-unused-function -Wimplicit-fallthrough -Wunreachable-code -Wsign-compare -Wno-deprecated-declarations )
 if( WERROR )
   set( WARNING_FLAGS ${WARNING_FLAGS} -Werror )
 endif( )
@@ -148,9 +127,8 @@ set(DEFAULT_GPUS
   gfx906
   gfx908
   gfx90a
-  gfx940
-  gfx941
   gfx942
+  gfx950
   gfx1030
   gfx1100
   gfx1101
@@ -166,8 +144,6 @@ if(BUILD_ADDRESS_SANITIZER)
   SET(DEFAULT_GPUS
     gfx908:xnack+
     gfx90a:xnack+
-    gfx940:xnack+
-    gfx941:xnack+
     gfx942:xnack+)
   add_link_options(-fuse-ld=lld)
   set(ROCFFT_KERNEL_CACHE_ENABLE off)
@@ -193,7 +169,8 @@ rocm_check_target_ids(AMDGPU_TARGETS TARGETS "${AMDGPU_TARGETS}")
 set(GPU_TARGETS "${AMDGPU_TARGETS}" CACHE STRING "GPU architectures to build for")
   
 # HIP is required - library and clients use HIP to access the device
-find_package( HIP REQUIRED CONFIG )
+find_package( hip REQUIRED CONFIG PATHS /opt/rocm/lib/cmake/hip/ )
+find_package( hiprtc REQUIRED CONFIG PATHS /opt/rocm/lib/cmake/hiprtc/ )
 
 # The nvidia backend can be used to compile for CUDA devices.
 # Specify the CUDA prefix in the CUDA_PREFIX variable.
@@ -287,7 +264,9 @@ endif( )
 if(WIN32)
   set(CPACK_SOURCE_GENERATOR "ZIP")
   set(CPACK_GENERATOR "ZIP")
-  set(CMAKE_INSTALL_PREFIX "C:/hipSDK" CACHE PATH "Install path" FORCE)
+  if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+    set(CMAKE_INSTALL_PREFIX "C:/hipSDK" CACHE PATH "Install path" FORCE)
+  endif()
   set(INSTALL_PREFIX "C:/hipSDK")
   set(CPACK_SET_DESTDIR OFF)
   set(CPACK_PACKAGE_INSTALL_DIRECTORY "C:/hipSDK")
@@ -321,3 +300,5 @@ rocm_create_package(
     LDCONFIG
     LDCONFIG_DIR ${ROCFFT_CONFIG_DIR}
 )
+
+option(BUILD_CODE_COVERAGE "Build with code coverage flags (clang only)" OFF)
diff --git a/LICENSE.md b/LICENSE.md
index 4c2aab7..d631884 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,12 +1,26 @@
-# License
+MIT License
 
-Copyright (C) 2016 - 2025 Advanced Micro Devices, Inc. All rights reserved.
+Copyright (C) Advanced Micro Devices, Inc.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
 
 This product includes software from copyright holders as shown below, and distributed under their license terms as specified.
 
diff --git a/README.md b/README.md
index fe133cb..8f943be 100644
--- a/README.md
+++ b/README.md
@@ -1,19 +1,18 @@
 # rocFFT
 
 rocFFT is a software library for computing fast Fourier transforms (FFTs) written in the HIP
-programming language. It's part of AMD's software ecosystem based on
-[ROCm](https://github.com/ROCm/ROCm). The rocFFT library can be used with AMD and
-NVIDIA GPUs.
+programming language. It's part of the AMD software ecosystem based on
+[ROCm](https://github.com/ROCm/ROCm). The rocFFT library can be used with AMD GPUs.
 
 ## Documentation
 
 > [!NOTE]
-> The published rocFFT documentation is available at [rocFFT](https://rocm.docs.amd.com/projects/rocFFT/en/latest/index.html) in an organized, easy-to-read format, with search and a table of contents. The documentation source files reside in the rocFFT/docs folder of this repository. As with all ROCm projects, the documentation is open source. For more information, see [Contribute to ROCm documentation](https://rocm.docs.amd.com/en/latest/contribute/contributing.html).
+> The published rocFFT documentation is available at [rocFFT](https://rocm.docs.amd.com/projects/rocFFT/en/latest/index.html) in an organized, easy-to-read format, with search and a table of contents. The documentation source files reside in the projects/rocfft/docs folder of the rocm-libraries repository. As with all ROCm projects, the documentation is open source. For more information, see [Contribute to ROCm documentation](https://rocm.docs.amd.com/en/latest/contribute/contributing.html).
 
 To build our documentation locally, use the following code:
 
 ```Bash
-cd docs
+cd projects/rocfft/docs
 
 pip3 install -r sphinx/requirements.txt
 
@@ -36,7 +35,7 @@ You can install rocFFT using pre-built packages or building from source.
 * Building from source:
 
     rocFFT is compiled with AMD's clang++ and uses CMake. You can specify several options to customize your
-    build. The following commands build a shared library for supported AMD GPUs:
+    build. The following commands build a shared library for supported AMD GPUs. Run these commands from the `rocm-libraries/projects/rocfft` directory:
 
     ```bash
     mkdir build && cd build
@@ -61,6 +60,7 @@ You can install rocFFT using pre-built packages or building from source.
     | `rocfft-bench` | `-DBUILD_CLIENTS_BENCH=on` | hipRAND |
     | `rocfft-test` | `-DBUILD_CLIENTS_TESTS=on` | hipRAND, FFTW, GoogleTest |
     | samples | `-DBUILD_CLIENTS_SAMPLES=on` | None |
+    | coverage | `-DBUILD_CODE_COVERAGE=ON` | clang, llvm-cov |
 
     Clients are not built by default. To build them, use `-DBUILD_CLIENTS=on`. The build process
     downloads and builds GoogleTest and FFTW if they are not already installed.
@@ -80,7 +80,14 @@ You can install rocFFT using pre-built packages or building from source.
     sudo apt install libgtest-dev libfftw3-dev libboost-dev
     ```
 
-    We use version 1.11 of GoogleTest.
+    rocFFT uses version 1.11 of GoogleTest.
+
+    You can generate a test coverage report with the following:
+    ```bash
+    cmake -DCMAKE_CXX_COMPILER=amdclang++ -DBUILD_CLIENTS_SAMPLES=ON -DBUILD_CLIENTS_TESTS=ON -DBUILD_CODE_COVERAGE=ON <optional: -DCOVERAGE_TEST_OPTIONS="cmdline args to pass to rocfft-test (default: --smoketest)"> ..
+    make -j coverage
+    ```
+    The above will output the coverage report to the terminal and also save an html coverage report to `$PWD/coverage-report`.
 
 ## Examples
 
@@ -91,9 +98,9 @@ You can find additional examples in the `clients/samples` subdirectory.
 
 ## Support
 
-You can report bugs and feature requests through the GitHub
-[issue tracker](https://github.com/ROCm/rocFFT/issues).
+You can report bugs and feature requests through the rocm-libraries GitHub
+[issue tracker](https://github.com/ROCm/rocm-libraries/issues).
 
 ## Contribute
 
-If you want to contribute to rocFFT, you must follow our [contribution guidelines](https://github.com/ROCm/rocFFT/blob/develop/.github/CONTRIBUTING.md).
+If you want to contribute to rocFFT, you must follow the [contribution guidelines](https://github.com/ROCm/rocm-libraries/blob/develop/projects/rocfft/.github/CONTRIBUTING.md).
diff --git a/clients/CMakeLists.txt b/clients/CMakeLists.txt
index 1f42485..44f361d 100644
--- a/clients/CMakeLists.txt
+++ b/clients/CMakeLists.txt
@@ -53,8 +53,8 @@ set(CMAKE_CXX_STANDARD 17)
 
 list( APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake )
 
-if( NOT ROCM_FOUND )
-  find_package( ROCM 0.7.3 REQUIRED )
+if( NOT ROCmCMakeBuildTools_FOUND )
+  find_package( ROCmCMakeBuildTools REQUIRED )
 endif()
 
 include( ROCMInstallTargets )
diff --git a/clients/bench/CMakeLists.txt b/clients/bench/CMakeLists.txt
index 60980fc..f792c0f 100644
--- a/clients/bench/CMakeLists.txt
+++ b/clients/bench/CMakeLists.txt
@@ -53,11 +53,11 @@ if( NOT TARGET rocfft )
 endif( )
 
 if( NOT HIP_FOUND )
-  find_package( HIP REQUIRED )
+  find_package( hip REQUIRED PATHS /opt/rocm/lib/cmake/hip/ )
 endif()
 
-if( NOT ROCM_FOUND )
-  find_package( ROCM 0.7.3 REQUIRED )
+if( NOT ROCmCMakeBuildTools_FOUND )
+  find_package( ROCmCMakeBuildTools REQUIRED )
 endif()
 
 if( USE_HIPRAND AND NOT hiprand_FOUND )
@@ -105,6 +105,7 @@ foreach( bench ${bench_list})
     PRIVATE
     hip::hiprand
     )
+    target_compile_definitions( ${bench} PRIVATE USE_HIPRAND )
   endif()
 
   # We need to include both rocfft.h and rocfft-export.h
@@ -155,30 +156,6 @@ foreach( bench ${bench_list})
                         ${BENCH_OUT_DIR} )
 
   rocm_install(TARGETS ${bench} COMPONENT benchmarks)
-
-  # install compatibility for old name of bench program - symlink on
-  # unix, hardlink on windows (since privilege is required to create
-  # symlinks there)
-  string(REPLACE bench rider bench_legacy ${bench})
-  if( WIN32 )
-    set( BENCH_LINK_COMMAND create_hardlink )
-    set( BENCH_NEW_NAME ${BENCH_OUT_DIR}/$<TARGET_FILE_BASE_NAME:${bench}>${CMAKE_EXECUTABLE_SUFFIX} )
-    set( BENCH_OLD_NAME ${BENCH_OUT_DIR}/${bench_legacy}${CMAKE_EXECUTABLE_SUFFIX} )
-  else()
-    set( BENCH_LINK_COMMAND create_symlink )
-    set( BENCH_NEW_NAME $<TARGET_FILE_BASE_NAME:${bench}> )
-    set( BENCH_OLD_NAME ${BENCH_OUT_DIR}/${bench_legacy} )
-  endif()
-  add_custom_command(
-      TARGET ${bench}
-      POST_BUILD
-      COMMAND ${CMAKE_COMMAND} -E ${BENCH_LINK_COMMAND} ${BENCH_NEW_NAME} ${BENCH_OLD_NAME}
-  )
-  install(
-    FILES ${BENCH_OLD_NAME}
-    DESTINATION ${CMAKE_INSTALL_BINDIR}
-    COMPONENT benchmarks
-  )
 endforeach()
 
 # Link dyna-rocfft-bench to the experimental filesystem library if
diff --git a/clients/bench/bench.cpp b/clients/bench/bench.cpp
index 96f4b8c..1d30106 100644
--- a/clients/bench/bench.cpp
+++ b/clients/bench/bench.cpp
@@ -87,7 +87,11 @@ int main(int argc, char* argv[])
                      "Type of transform:\n0) complex forward\n1) complex inverse\n2) real "
                      "forward\n3) real inverse")
         ->default_val(fft_transform_type_complex_forward);
-
+    non_token
+        ->add_option("--auto_allocation",
+                     params.auto_allocate,
+                     "rocFFT's auto-allocation behavior: \"on\", \"off\", or \"default\"")
+        ->default_val("default");
     non_token
         ->add_option(
             "--precision", params.precision, "Transform precision: single (default), double, half")
@@ -201,7 +205,10 @@ int main(int argc, char* argv[])
             params.mp_lib = fft_params::fft_mp_lib_none;
 
             int localDeviceCount = 0;
-            (void)hipGetDeviceCount(&localDeviceCount);
+            if(hipGetDeviceCount(&localDeviceCount) != hipSuccess)
+            {
+                throw std::runtime_error("hipGetDeviceCount failed");
+            }
 
             // start with all-ones in grids
             std::vector<unsigned int> input_grid(params.length.size() + 1, 1);
@@ -333,119 +340,49 @@ int main(int argc, char* argv[])
         LIB_V_THROW(rocfft_status_failure, "Plan creation failed");
 
     // GPU input buffer:
-    auto                ibuffer_sizes = params.ibuffer_sizes();
-    std::vector<gpubuf> ibuffer(ibuffer_sizes.size());
-    std::vector<void*>  pibuffer(ibuffer_sizes.size());
-    for(unsigned int i = 0; i < ibuffer.size(); ++i)
-    {
-        try
-        {
-            HIP_V_THROW(ibuffer[i].alloc(ibuffer_sizes[i]), "Creating input Buffer failed");
-        }
-        catch(rocfft_hip_runtime_error)
-        {
-            return ignore_hip_runtime_failures ? EXIT_SUCCESS : EXIT_FAILURE;
-        }
-        pibuffer[i] = ibuffer[i].data();
-    }
-
+    std::vector<gpubuf> ibuffer;
+    std::vector<void*>  pibuffer;
     // CPU-side input buffer
     std::vector<hostbuf> ibuffer_cpu;
 
     auto is_host_gen = (params.igen == fft_input_generator_host
                         || params.igen == fft_input_random_generator_host);
 
-#ifdef USE_HIPRAND
-    if(!is_host_gen)
-    {
-        // Input data:
-        params.compute_input(ibuffer);
+    auto ibricks = get_input_bricks(params);
+    auto obricks = get_output_bricks(params);
 
-        if(verbose > 1)
-        {
-            // Copy input to CPU
-            try
-            {
-                ibuffer_cpu = allocate_host_buffer(params.precision, params.itype, params.isize);
-            }
-            catch(rocfft_hip_runtime_error)
-            {
-                return ignore_hip_runtime_failures ? EXIT_SUCCESS : EXIT_FAILURE;
-            }
-            for(unsigned int idx = 0; idx < ibuffer.size(); ++idx)
-            {
-                try
-                {
-                    HIP_V_THROW(hipMemcpy(ibuffer_cpu.at(idx).data(),
-                                          ibuffer[idx].data(),
-                                          ibuffer_sizes[idx],
-                                          hipMemcpyDeviceToHost),
-                                "hipMemcpy failed");
-                }
-                catch(rocfft_hip_runtime_error)
-                {
-                    return ignore_hip_runtime_failures ? EXIT_SUCCESS : EXIT_FAILURE;
-                }
-            }
+    std::vector<gpubuf>  obuffer_data;
+    std::vector<gpubuf>* obuffer = nullptr;
+    alloc_bench_bricks(
+        params, ibricks, obricks, ibuffer, obuffer_data, obuffer, ibuffer_cpu, is_host_gen);
 
-            std::cout << "GPU input:\n";
-            params.print_ibuffer(ibuffer_cpu);
-        }
-    }
-#endif
-    if(is_host_gen)
+    pibuffer.resize(ibuffer.size());
+    for(unsigned int i = 0; i < ibuffer.size(); ++i)
     {
-        // Input data:
-        ibuffer_cpu = allocate_host_buffer(params.precision, params.itype, params.isize);
-        params.compute_input(ibuffer_cpu);
+        pibuffer[i] = ibuffer[i].data();
+    }
 
-        if(verbose > 1)
+    // print input if requested
+    if(verbose > 1)
+    {
+        if(is_host_gen)
         {
-            std::cout << "GPU input:\n";
+            // data is already on host
             params.print_ibuffer(ibuffer_cpu);
         }
-
-        for(unsigned int idx = 0; idx < ibuffer_cpu.size(); ++idx)
+        else
         {
-            try
-            {
-                HIP_V_THROW(hipMemcpy(pibuffer[idx],
-                                      ibuffer_cpu[idx].data(),
-                                      ibuffer_cpu[idx].size(),
-                                      hipMemcpyHostToDevice),
-                            "hipMemcpy failed");
-            }
-            catch(rocfft_hip_runtime_error)
-            {
-                return ignore_hip_runtime_failures ? EXIT_SUCCESS : EXIT_FAILURE;
-            }
+            print_device_buffer(params, ibuffer, true);
         }
     }
 
-    // GPU output buffer:
-    std::vector<gpubuf>  obuffer_data;
-    std::vector<gpubuf>* obuffer = &obuffer_data;
-    if(params.placement == fft_placement_inplace)
-    {
-        obuffer = &ibuffer;
-    }
-    else
-    {
-        auto obuffer_sizes = params.obuffer_sizes();
-        obuffer_data.resize(obuffer_sizes.size());
-        for(unsigned int i = 0; i < obuffer_data.size(); ++i)
-        {
-            HIP_V_THROW(obuffer_data[i].alloc(obuffer_sizes[i]), "Creating output Buffer failed");
-        }
-    }
     std::vector<void*> pobuffer(obuffer->size());
     for(unsigned int i = 0; i < obuffer->size(); ++i)
     {
         pobuffer[i] = obuffer->at(i).data();
     }
 
-    // Scatter input out to other devices and adjust I/O buffers to match requested transform
-    params.multi_gpu_prepare(ibuffer, pibuffer, pobuffer);
+    init_bench_input(params, ibricks, ibuffer, ibuffer_cpu, is_host_gen);
 
     // Execute a warm-up call
     params.execute(pibuffer.data(), pobuffer.data());
@@ -459,34 +396,13 @@ int main(int argc, char* argv[])
     for(unsigned int itrial = 0; itrial < gpu_time.size(); ++itrial)
     {
         // Create input at every iteration to avoid overflow
-        if(params.ifields.empty())
+        if(is_host_gen)
         {
-#ifdef USE_HIPRAND
-            // Compute input on default device
-            if(!is_host_gen)
-                params.compute_input(ibuffer);
-#endif
-            if(is_host_gen)
-            {
-                for(unsigned int idx = 0; idx < ibuffer_cpu.size(); ++idx)
-                {
-                    try
-                    {
-                        HIP_V_THROW(hipMemcpy(pibuffer[idx],
-                                              ibuffer_cpu[idx].data(),
-                                              ibuffer_cpu[idx].size(),
-                                              hipMemcpyHostToDevice),
-                                    "hipMemcpy failed");
-                    }
-                    catch(rocfft_hip_runtime_error)
-                    {
-                        return ignore_hip_runtime_failures ? EXIT_SUCCESS : EXIT_FAILURE;
-                    }
-                }
-            }
-
-            // Scatter input out to other devices if this is a multi-GPU test
-            params.multi_gpu_prepare(ibuffer, pibuffer, pobuffer);
+            copy_host_input_to_dev(ibuffer_cpu, ibuffer);
+        }
+        else
+        {
+            init_bench_input(params, ibricks, ibuffer, ibuffer_cpu, is_host_gen);
         }
 
         HIP_V_THROW(hipEventRecord(start), "hipEventRecord failed");
@@ -503,27 +419,7 @@ int main(int argc, char* argv[])
         // Print result after FFT transform
         if(verbose > 2)
         {
-            // Gather data to default GPU if this is a multi-GPU test
-            params.multi_gpu_finalize(*obuffer, pobuffer);
-
-            auto output = allocate_host_buffer(params.precision, params.otype, params.osize);
-            for(unsigned int idx = 0; idx < output.size(); ++idx)
-            {
-                try
-                {
-                    HIP_V_THROW(hipMemcpy(output[idx].data(),
-                                          pobuffer.at(idx),
-                                          output[idx].size(),
-                                          hipMemcpyDeviceToHost),
-                                "hipMemcpy failed");
-                }
-                catch(rocfft_hip_runtime_error)
-                {
-                    return ignore_hip_runtime_failures ? EXIT_SUCCESS : EXIT_FAILURE;
-                }
-            }
-            std::cout << "GPU output:\n";
-            params.print_obuffer(output);
+            print_device_buffer(params, *obuffer, false);
         }
     }
 
diff --git a/clients/bench/bench.h b/clients/bench/bench.h
index 51804ac..de06f93 100644
--- a/clients/bench/bench.h
+++ b/clients/bench/bench.h
@@ -21,6 +21,9 @@
 #ifndef ROCFFT_BENCH_H
 #define ROCFFT_BENCH_H
 
+#include "../../shared/fft_params.h"
+#include "../../shared/rocfft_hip.h"
+
 #include "rocfft/rocfft.h"
 #include <hip/hip_runtime_api.h>
 #include <vector>
@@ -92,4 +95,198 @@ inline void lib_V_Throw(rocfft_status      res,
 #define HIP_V_THROW(_status, _message) hip_V_Throw(_status, _message, __LINE__, __FILE__)
 #define LIB_V_THROW(_status, _message) lib_V_Throw(_status, _message, __LINE__, __FILE__)
 
+// return input bricks for params, or one big brick covering the
+// input field if no bricks are specified
+template <typename Tparams>
+std::vector<fft_params::fft_brick> get_input_bricks(const Tparams& params)
+{
+    std::vector<fft_params::fft_brick> bricks;
+    if(!params.ifields.empty())
+        bricks = params.ifields[0].bricks;
+    else
+    {
+        auto len = params.ilength();
+
+        // just make one big brick covering the whole input field
+        bricks.resize(1);
+        bricks.front().lower.resize(len.size() + 1);
+        bricks.front().upper.resize(len.size() + 1);
+        bricks.front().stride.resize(len.size() + 1);
+
+        bricks.front().upper.front() = params.nbatch;
+        std::copy(len.begin(), len.end(), bricks.front().upper.begin() + 1);
+
+        bricks.front().stride.front() = params.idist;
+        std::copy(params.istride.begin(), params.istride.end(), bricks.front().stride.begin() + 1);
+    }
+    return bricks;
+}
+
+// return output bricks for params, or one big brick covering the
+// output field if no bricks are specified
+template <typename Tparams>
+std::vector<fft_params::fft_brick> get_output_bricks(const Tparams& params)
+{
+    std::vector<fft_params::fft_brick> bricks;
+    if(!params.ofields.empty())
+        bricks = params.ofields[0].bricks;
+    else
+    {
+        auto len = params.olength();
+
+        // just make one big brick covering the whole output field
+        bricks.resize(1);
+        bricks.front().lower.resize(len.size() + 1);
+        bricks.front().upper.resize(len.size() + 1);
+        bricks.front().stride.resize(len.size() + 1);
+
+        bricks.front().upper.front() = params.nbatch;
+        std::copy(len.begin(), len.end(), bricks.front().upper.begin() + 1);
+
+        bricks.front().stride.front() = params.odist;
+        std::copy(params.ostride.begin(), params.ostride.end(), bricks.front().stride.begin() + 1);
+    }
+    return bricks;
+}
+
+// Allocate input/output buffers for a bench run.
+template <typename Tparams>
+void alloc_bench_bricks(const Tparams&                            params,
+                        const std::vector<fft_params::fft_brick>& ibricks,
+                        const std::vector<fft_params::fft_brick>& obricks,
+                        std::vector<gpubuf>&                      ibuffers,
+                        std::vector<gpubuf>&                      obuffer_data,
+                        std::vector<gpubuf>*&                     obuffers,
+                        std::vector<hostbuf>&                     host_buffers,
+                        bool                                      is_host_gen)
+{
+    auto alloc_buffers = [&params, &host_buffers](const std::vector<fft_params::fft_brick>& bricks,
+                                                  fft_array_type                            type,
+                                                  std::vector<gpubuf>&                      output,
+                                                  bool is_host_gen) {
+        auto       elem_size = var_size<size_t>(params.precision, type);
+        const bool is_planar
+            = type == fft_array_type_complex_planar || type == fft_array_type_hermitian_planar;
+        // alloc 2x buffers, each half size for planar
+        if(is_planar)
+            elem_size /= 2;
+
+        for(const auto& b : bricks)
+        {
+            rocfft_scoped_device dev(b.device);
+
+            size_t brick_size_bytes = compute_ptrdiff(b.length(), b.stride, 0, 0) * elem_size;
+            output.emplace_back();
+            if(output.back().alloc(brick_size_bytes) != hipSuccess)
+                throw std::runtime_error("hipMalloc failed");
+            if(is_planar)
+            {
+                output.emplace_back();
+                if(output.back().alloc(brick_size_bytes) != hipSuccess)
+                    throw std::runtime_error("hipMalloc failed");
+            }
+            if(is_host_gen)
+            {
+                host_buffers.emplace_back();
+                host_buffers.back().alloc(brick_size_bytes);
+                if(is_planar)
+                {
+                    host_buffers.emplace_back();
+                    host_buffers.back().alloc(brick_size_bytes);
+                }
+            }
+        }
+    };
+
+    // If brick shape differs, inplace is only allowed for single
+    // bricks.  e.g. in-place real-complex
+    if(params.placement == fft_placement_inplace)
+    {
+        if(ibricks.size() != 1 && obricks.size() != 1 && ibricks != obricks)
+            throw std::runtime_error(
+                "in-place transform to different brick shapes only allowed for single bricks");
+
+        // allocate the larger of the two bricks
+        auto isize_bytes = compute_ptrdiff(ibricks.front().length(), ibricks.front().stride, 0, 0)
+                           * var_size<size_t>(params.precision, params.itype);
+        auto osize_bytes = compute_ptrdiff(obricks.front().length(), obricks.front().stride, 0, 0)
+                           * var_size<size_t>(params.precision, params.otype);
+
+        alloc_buffers(isize_bytes > osize_bytes ? ibricks : obricks,
+                      isize_bytes > osize_bytes ? params.itype : params.otype,
+                      ibuffers,
+                      is_host_gen);
+        obuffers = &ibuffers;
+    }
+    else
+    {
+        alloc_buffers(ibricks, params.itype, ibuffers, is_host_gen);
+        alloc_buffers(obricks, params.otype, obuffer_data, false);
+        obuffers = &obuffer_data;
+    }
+}
+
+void copy_host_input_to_dev(std::vector<hostbuf>& host_buffers, std::vector<gpubuf>& buffers)
+{
+    for(size_t i = 0; i < buffers.size(); ++i)
+    {
+        if(hipMemcpy(buffers[i].data(),
+                     host_buffers[i].data(),
+                     host_buffers[i].size(),
+                     hipMemcpyHostToDevice)
+           != hipSuccess)
+            throw std::runtime_error("hipMemcpy failure");
+    }
+}
+
+template <typename Tparams>
+void init_bench_input(const Tparams&                            params,
+                      const std::vector<fft_params::fft_brick>& bricks,
+                      std::vector<gpubuf>&                      buffers,
+                      std::vector<hostbuf>&                     host_buffers,
+                      bool                                      is_host_gen)
+{
+    auto elem_size = var_size<size_t>(params.precision, params.itype);
+    if(is_host_gen)
+    {
+        std::vector<void*> ptrs;
+        ptrs.reserve(host_buffers.size());
+        for(auto& buf : host_buffers)
+            ptrs.push_back(buf.data());
+
+        init_local_input<Tparams, hostbuf>(0, params, bricks, elem_size, ptrs);
+        copy_host_input_to_dev(host_buffers, buffers);
+    }
+    else
+    {
+#ifdef USE_HIPRAND
+        std::vector<void*> ptrs;
+        ptrs.reserve(buffers.size());
+        for(auto& buf : buffers)
+            ptrs.push_back(buf.data());
+
+        init_local_input<Tparams, gpubuf>(0, params, bricks, elem_size, ptrs);
+#endif
+    }
+}
+
+template <typename Tparams>
+void print_device_buffer(const Tparams& params, std::vector<gpubuf>& buffer, bool input)
+{
+    // copy data back to host
+    std::vector<hostbuf> print_buffer;
+    for(auto& buf : buffer)
+    {
+        print_buffer.emplace_back();
+        print_buffer.back().alloc(buf.size());
+        if(hipMemcpy(print_buffer.back().data(), buf.data(), buf.size(), hipMemcpyDeviceToHost)
+           != hipSuccess)
+            throw std::runtime_error("hipMemcpy failed");
+    }
+    if(input)
+        params.print_ibuffer(print_buffer);
+    else
+        params.print_obuffer(print_buffer);
+}
+
 #endif // ROCFFT_BENCH_H
diff --git a/clients/bench/dyna-bench.cpp b/clients/bench/dyna-bench.cpp
index 7e50435..b121887 100644
--- a/clients/bench/dyna-bench.cpp
+++ b/clients/bench/dyna-bench.cpp
@@ -458,7 +458,10 @@ int main(int argc, char* argv[])
             params.mp_lib = fft_params::fft_mp_lib_none;
 
             int localDeviceCount = 0;
-            (void)hipGetDeviceCount(&localDeviceCount);
+            if(hipGetDeviceCount(&localDeviceCount) != hipSuccess)
+            {
+                throw std::runtime_error("hipGetDeviceCount failed");
+            }
 
             // start with all-ones in grids
             std::vector<unsigned int> input_grid(params.length.size() + 1, 1);
@@ -574,112 +577,42 @@ int main(int argc, char* argv[])
     }
 
     // GPU input buffer:
-    auto                ibuffer_sizes = params.ibuffer_sizes();
-    std::vector<gpubuf> ibuffer(ibuffer_sizes.size());
-    std::vector<void*>  pibuffer(ibuffer_sizes.size());
-    for(unsigned int i = 0; i < ibuffer.size(); ++i)
-    {
-        try
-        {
-            HIP_V_THROW(ibuffer[i].alloc(ibuffer_sizes[i]), "Creating input Buffer failed");
-        }
-        catch(rocfft_hip_runtime_error)
-        {
-            return ignore_hip_runtime_failures ? EXIT_SUCCESS : EXIT_FAILURE;
-        }
-        pibuffer[i] = ibuffer[i].data();
-    }
-
+    std::vector<gpubuf> ibuffer;
+    std::vector<void*>  pibuffer;
     // CPU-side input buffer
     std::vector<hostbuf> ibuffer_cpu;
 
     auto is_host_gen = (params.igen == fft_input_generator_host
                         || params.igen == fft_input_random_generator_host);
 
-#ifdef USE_HIPRAND
-    if(!is_host_gen)
-    {
-        // Input data:
-        params.compute_input(ibuffer);
+    auto ibricks = get_input_bricks(params);
+    auto obricks = get_output_bricks(params);
 
-        if(verbose > 1)
-        {
-            // Copy input to CPU
-            ibuffer_cpu = allocate_host_buffer(params.precision, params.itype, params.isize);
-            for(unsigned int idx = 0; idx < ibuffer.size(); ++idx)
-            {
-                try
-                {
-                    HIP_V_THROW(hipMemcpy(ibuffer_cpu.at(idx).data(),
-                                          ibuffer[idx].data(),
-                                          ibuffer_sizes[idx],
-                                          hipMemcpyDeviceToHost),
-                                "hipMemcpy failed");
-                }
-                catch(rocfft_hip_runtime_error)
-                {
-                    return ignore_hip_runtime_failures ? EXIT_SUCCESS : EXIT_FAILURE;
-                }
-            }
+    std::vector<gpubuf>  obuffer_data;
+    std::vector<gpubuf>* obuffer = nullptr;
+    alloc_bench_bricks(
+        params, ibricks, obricks, ibuffer, obuffer_data, obuffer, ibuffer_cpu, is_host_gen);
+    init_bench_input(params, ibricks, ibuffer, ibuffer_cpu, is_host_gen);
 
-            std::cout << "GPU input:\n";
-            params.print_ibuffer(ibuffer_cpu);
-        }
-    }
-#endif
-    if(is_host_gen)
+    for(unsigned int i = 0; i < ibuffer.size(); ++i)
     {
-        // Input data:
-        ibuffer_cpu = allocate_host_buffer(params.precision, params.itype, params.isize);
-        params.compute_input(ibuffer_cpu);
+        pibuffer.push_back(ibuffer[i].data());
+    }
 
-        if(verbose > 1)
+    // print input if requested
+    if(verbose > 1)
+    {
+        if(is_host_gen)
         {
-            std::cout << "GPU input:\n";
+            // data is already on host
             params.print_ibuffer(ibuffer_cpu);
         }
-
-        for(unsigned int idx = 0; idx < ibuffer_cpu.size(); ++idx)
+        else
         {
-            try
-            {
-                HIP_V_THROW(hipMemcpy(pibuffer[idx],
-                                      ibuffer_cpu[idx].data(),
-                                      ibuffer_cpu[idx].size(),
-                                      hipMemcpyHostToDevice),
-                            "hipMemcpy failed");
-            }
-            catch(rocfft_hip_runtime_error)
-            {
-                return ignore_hip_runtime_failures ? EXIT_SUCCESS : EXIT_FAILURE;
-            }
+            print_device_buffer(params, ibuffer, true);
         }
     }
 
-    // GPU output buffer:
-    std::vector<gpubuf>  obuffer_data;
-    std::vector<gpubuf>* obuffer = &obuffer_data;
-    if(params.placement == fft_placement_inplace)
-    {
-        obuffer = &ibuffer;
-    }
-    else
-    {
-        auto obuffer_sizes = params.obuffer_sizes();
-        obuffer_data.resize(obuffer_sizes.size());
-        for(unsigned int i = 0; i < obuffer_data.size(); ++i)
-        {
-            try
-            {
-                HIP_V_THROW(obuffer_data[i].alloc(obuffer_sizes[i]),
-                            "Creating output Buffer failed");
-            }
-            catch(rocfft_hip_runtime_error)
-            {
-                return ignore_hip_runtime_failures ? EXIT_SUCCESS : EXIT_FAILURE;
-            }
-        }
-    }
     std::vector<void*> pobuffer(obuffer->size());
     for(unsigned int i = 0; i < obuffer->size(); ++i)
     {
diff --git a/clients/samples/fixed-16/CMakeLists.txt b/clients/samples/fixed-16/CMakeLists.txt
index feec728..d74f03b 100644
--- a/clients/samples/fixed-16/CMakeLists.txt
+++ b/clients/samples/fixed-16/CMakeLists.txt
@@ -49,7 +49,7 @@ if( NOT TARGET rocfft )
 endif( )
 
 if( NOT HIP_FOUND )
-  find_package( HIP REQUIRED )
+  find_package( hip REQUIRED PATHS /opt/rocm/lib/cmake/hip/ )
 endif()
 
 set( sample_list fixed-16-float fixed-16-double fixed-16-half )
diff --git a/clients/samples/fixed-large/CMakeLists.txt b/clients/samples/fixed-large/CMakeLists.txt
index bf1c2e7..ddea865 100644
--- a/clients/samples/fixed-large/CMakeLists.txt
+++ b/clients/samples/fixed-large/CMakeLists.txt
@@ -49,7 +49,7 @@ if( NOT TARGET rocfft )
 endif( )
 
 if( NOT HIP_FOUND )
-  find_package( HIP REQUIRED )
+  find_package( hip REQUIRED PATHS /opt/rocm/lib/cmake/hip/ )
 endif()
 
 set( sample_list fixed-large-float fixed-large-double )
diff --git a/clients/samples/mpi/CMakeLists.txt b/clients/samples/mpi/CMakeLists.txt
index 836e652..e4122bc 100644
--- a/clients/samples/mpi/CMakeLists.txt
+++ b/clients/samples/mpi/CMakeLists.txt
@@ -49,7 +49,7 @@ if( NOT TARGET rocfft )
 endif( )
 
 if( NOT HIP_FOUND )
-  find_package( HIP REQUIRED )
+  find_package( hip REQUIRED PATHS /opt/rocm/lib/cmake/hip/ )
 endif()
 
 if( NOT MPI_FOUND )
@@ -97,6 +97,7 @@ foreach( sample ${sample_list} )
     PRIVATE
     hip::hiprand
     )
+    target_compile_definitions( ${sample} PRIVATE USE_HIPRAND )
   endif()
 
   target_compile_options( ${sample} PRIVATE ${WARNING_FLAGS} -Wno-cpp )
diff --git a/clients/samples/mpi/rocfft_mpi_example.cpp b/clients/samples/mpi/rocfft_mpi_example.cpp
index 14f06dc..18fbd12 100644
--- a/clients/samples/mpi/rocfft_mpi_example.cpp
+++ b/clients/samples/mpi/rocfft_mpi_example.cpp
@@ -126,6 +126,11 @@ int main(int argc, char** argv)
     if(fftrc != rocfft_status_success)
         throw std::runtime_error("failed to create description");
 
+    // This example is unbatched, so the batch stride is not used
+    // for anything.  For batched examples, this would be
+    // distance in elements between consecutive batches.
+    const size_t batch_stride = 0;
+
     if(mpi_rank == 0)
     {
         std::cout << "input data decomposition:\n";
@@ -135,14 +140,14 @@ int main(int argc, char** argv)
         rocfft_field infield = nullptr;
         rocfft_field_create(&infield);
 
-        std::vector<size_t> inbrick_stride  = {1, length[1]};
+        std::vector<size_t> inbrick_stride  = {1, length[1], batch_stride};
         const size_t        inbrick_length1 = length[1] / (size_t)mpi_size
                                        + ((size_t)mpi_rank < length[1] % (size_t)mpi_size ? 1 : 0);
         const size_t inbrick_lower1
             = mpi_rank * (length[1] / mpi_size) + std::min((size_t)mpi_rank, length[1] % mpi_size);
         const size_t        inbrick_upper1 = inbrick_lower1 + inbrick_length1;
-        std::vector<size_t> inbrick_lower  = {0, inbrick_lower1};
-        std::vector<size_t> inbrick_upper  = {length[0], inbrick_upper1};
+        std::vector<size_t> inbrick_lower  = {0, inbrick_lower1, 0};
+        std::vector<size_t> inbrick_upper  = {length[0], inbrick_upper1, 1};
 
         rocfft_brick inbrick = nullptr;
         rocfft_brick_create(&inbrick,
@@ -219,15 +224,15 @@ int main(int argc, char** argv)
     std::vector<void*>  gpu_out = {nullptr};
     std::vector<size_t> outbrick_lower;
     std::vector<size_t> outbrick_upper;
-    std::vector<size_t> outbrick_stride = {1, length[1]};
+    std::vector<size_t> outbrick_stride = {1, length[1], batch_stride};
     {
         const size_t outbrick_length1 = length[1] / (size_t)mpi_size
                                         + ((size_t)mpi_rank < length[1] % (size_t)mpi_size ? 1 : 0);
         const size_t outbrick_lower1
             = mpi_rank * (length[1] / mpi_size) + std::min((size_t)mpi_rank, length[1] % mpi_size);
         const size_t outbrick_upper1 = outbrick_lower1 + outbrick_length1;
-        outbrick_lower               = {0, outbrick_lower1};
-        outbrick_upper               = {length[0], outbrick_upper1};
+        outbrick_lower               = {0, outbrick_lower1, 0};
+        outbrick_upper               = {length[0], outbrick_upper1, 1};
 
         const size_t memSize = length[0] * outbrick_length1 * sizeof(std::complex<double>);
         for(int irank = 0; irank < mpi_size; ++irank)
@@ -254,8 +259,8 @@ int main(int argc, char** argv)
         rocfft_field_create(&outfield);
 
         rocfft_brick outbrick = nullptr;
-        outbrick_lower        = {0, outbrick_lower1};
-        outbrick_upper        = {length[0], outbrick_lower1 + outbrick_length1};
+        outbrick_lower        = {0, outbrick_lower1, 0};
+        outbrick_upper        = {length[0], outbrick_lower1 + outbrick_length1, 1};
         rocfft_brick_create(&outbrick,
                             outbrick_lower.data(),
                             outbrick_upper.data(),
diff --git a/clients/samples/multi_gpu/CMakeLists.txt b/clients/samples/multi_gpu/CMakeLists.txt
index 41bc5e0..f4b1b27 100644
--- a/clients/samples/multi_gpu/CMakeLists.txt
+++ b/clients/samples/multi_gpu/CMakeLists.txt
@@ -49,7 +49,7 @@ if( NOT TARGET rocfft )
 endif( )
 
 if( NOT HIP_FOUND )
-  find_package( HIP REQUIRED )
+  find_package( hip REQUIRED PATHS /opt/rocm/lib/cmake/hip/ )
 endif()
 
 if( USE_HIPRAND AND NOT hiprand_FOUND )
@@ -79,6 +79,7 @@ foreach( sample ${sample_list} )
       PRIVATE
       hip::hiprand
     )
+    target_compile_definitions( ${sample} PRIVATE USE_HIPRAND )
   endif()
 
   target_compile_options( ${sample} PRIVATE ${WARNING_FLAGS} -Wno-cpp )
diff --git a/clients/samples/rocfft/CMakeLists.txt b/clients/samples/rocfft/CMakeLists.txt
index d883915..01d47d6 100644
--- a/clients/samples/rocfft/CMakeLists.txt
+++ b/clients/samples/rocfft/CMakeLists.txt
@@ -49,7 +49,7 @@ if( NOT TARGET rocfft )
 endif( )
 
 if( NOT HIP_FOUND )
-  find_package( HIP REQUIRED )
+  find_package( hip REQUIRED PATHS /opt/rocm/lib/cmake/hip/ )
 endif()
 
 if( USE_HIPRAND AND NOT hiprand_FOUND )
@@ -80,6 +80,7 @@ foreach( sample ${sample_list} )
       PRIVATE
       hip::hiprand
       )
+    target_compile_definitions( ${sample} PRIVATE USE_HIPRAND )
   endif()
 
   target_compile_options( ${sample} PRIVATE ${WARNING_FLAGS} -Wno-cpp )
@@ -116,3 +117,10 @@ foreach( sample ${sample_list} )
   target_link_libraries( ${sample} PRIVATE ${ROCFFT_CLIENTS_HOST_LINK_LIBS} ${ROCFFT_CLIENTS_DEVICE_LINK_LIBS} )
 
 endforeach( )
+
+# callback functions need to be built as relocatable device code
+# (causes failure at link stage on Windows)
+if (NOT WIN32)
+  target_compile_options( rocfft_example_callback PRIVATE -fgpu-rdc )
+  target_link_options( rocfft_example_callback PRIVATE -fgpu-rdc )
+endif()
diff --git a/clients/samples/rocfft/rocfft_example_callback.cpp b/clients/samples/rocfft/rocfft_example_callback.cpp
index a6c2dd3..ccc65e5 100644
--- a/clients/samples/rocfft/rocfft_example_callback.cpp
+++ b/clients/samples/rocfft/rocfft_example_callback.cpp
@@ -20,11 +20,12 @@
 * THE SOFTWARE.
 *******************************************************************************/
 
+#include <iostream>
+#ifndef WIN32
 #include "rocfft/rocfft.h"
 #include <hip/hip_complex.h>
 #include <hip/hip_runtime.h>
 #include <hip/hip_vector_types.h>
-#include <iostream>
 #include <math.h>
 #include <stdexcept>
 #include <vector>
@@ -46,9 +47,14 @@ __device__ double2 load_callback(double2* input, size_t offset, void* cbdata, vo
                    make_hipDoubleComplex(data->scale, data->scale));
 }
 __device__ auto load_callback_dev = load_callback;
+#endif
 
 int main()
 {
+#ifdef WIN32
+    std::cout << "This sample is temporarily disabled on Windows" << std::endl;
+    return EXIT_SUCCESS;
+#else
 
     const size_t N = 8;
 
@@ -189,4 +195,5 @@ int main()
         throw std::runtime_error("rocfft_cleanup failed.");
 
     return 0;
+#endif
 }
diff --git a/clients/tests/CMakeLists.txt b/clients/tests/CMakeLists.txt
index 83ed823..81037c0 100644
--- a/clients/tests/CMakeLists.txt
+++ b/clients/tests/CMakeLists.txt
@@ -53,11 +53,11 @@ if( NOT TARGET rocfft )
 endif( )
 
 if( NOT HIP_FOUND )
-  find_package( HIP REQUIRED )
+  find_package( hip REQUIRED PATHS /opt/rocm/lib/cmake/hip/ )
 endif()
 
-if( NOT ROCM_FOUND )
-  find_package( ROCM 0.7.3 REQUIRED )
+if( NOT ROCmCMakeBuildTools_FOUND )
+  find_package( ROCmCMakeBuildTools REQUIRED )
 endif()
 
 if( USE_HIPRAND AND NOT hiprand_FOUND )
@@ -94,6 +94,19 @@ set( rocfft-test_source
 add_executable( rocfft-test ${rocfft-test_source} ${rocfft-test_includes} )
 add_executable( rtc_helper_crash rtc_helper_crash.cpp )
 
+# rocFFT device code builds with -O3 by default.  rocfft-test
+# contains device code for callback functions, so ensure the device
+# code is built with the same optimization level to minimize chance
+# of a mismatch
+target_compile_options( rocfft-test PRIVATE -Xarch_device -O3 )
+
+# callback functions need to be built as relocatable device code
+# (causes failure at link stage on Windows)
+if (NOT WIN32)
+  target_compile_options( rocfft-test PRIVATE -fgpu-rdc )
+  target_link_options( rocfft-test PRIVATE -fgpu-rdc )
+endif()
+
 find_package( Boost REQUIRED )
 set( Boost_DEBUG ON )
 set( Boost_DETAILED_FAILURE_MSG ON )
@@ -183,15 +196,38 @@ set( rocfft-test_link_libs
   ${FFTW_LIBRARIES}
   )
 
-include( ../cmake/build-gtest.cmake )
+option( BUILD_CLIENTS_TESTS_OPENMP "Build tests with OpenMP" ON )
+if( BUILD_CLIENTS_TESTS_OPENMP )
+  # Attempt to find a config version, which provides openmp_LIB_DIR.
+  #find_package( OpenMP CONFIG PATHS "${HIP_CLANG_ROOT}/lib/cmake" )
+  if( NOT OPENMP_FOUND OR NOT DEFINED ${openmp_LIB_DIR} )
+     # Fall-back to module mode.
+     find_package( OpenMP REQUIRED )
+     set( BUILD_RPATH "${HIP_CLANG_ROOT}/lib" )
+     set( INSTALL_RPATH "$ORIGIN/../llvm/lib" )
+  else()
+     set( BUILD_RPATH "${HIP_CLANG_ROOT}/${openmp_LIB_DIR}" )
+     set( INSTALL_RPATH "$ORIGIN/../llvm/${openmp_LIB_DIR}" )
+  endif()
+  list( APPEND rocfft-test_link_libs OpenMP::OpenMP_CXX )	
+
+  set_target_properties( rocfft-test PROPERTIES
+     BUILD_RPATH "{$BUILD_RPATH}"
+  )
+  set_target_properties( rocfft-test PROPERTIES
+    INSTALL_RPATH "${INSTALL_RPATH}"
+  )
+endif()
+
+find_package( GTest QUIET )
 
-if( BUILD_GTEST OR NOT GTEST_FOUND )
+if( GTest_FOUND )
+    target_link_libraries( rocfft-test PRIVATE GTest::gtest )
+else()
+  include( ../cmake/build-gtest.cmake )
   add_dependencies( rocfft-test gtest )
   list( APPEND rocfft-test_include_dirs ${GTEST_INCLUDE_DIRS} )
   list( APPEND rocfft-test_link_libs ${GTEST_LIBRARIES} )
-else()  
-  list( APPEND rocfft-test_include_dirs $<BUILD_INTERFACE:${GTEST_INCLUDE_DIRS}> )
-  list( APPEND rocfft-test_link_libs ${GTEST_LIBRARIES} )
 endif()
 
 target_compile_options( rocfft-test PRIVATE ${WARNING_FLAGS} -Wno-cpp )
@@ -223,6 +259,7 @@ if ( USE_HIPRAND )
   PRIVATE
   hip::hiprand
   )
+  target_compile_definitions( rocfft-test PRIVATE USE_HIPRAND )
 endif()
 
 if( ROCFFT_MPI_ENABLE )
@@ -256,7 +293,9 @@ if( USE_CUDA )
     )
   target_compile_definitions( rocfft-test PRIVATE __HIP_PLATFORM_NVCC__ )
 endif( )
-target_link_libraries( rocfft-test PRIVATE ${ROCFFT_CLIENTS_HOST_LINK_LIBS} ${ROCFFT_CLIENTS_DEVICE_LINK_LIBS} )
+target_link_libraries( rocfft-test PRIVATE
+   ${ROCFFT_CLIENTS_HOST_LINK_LIBS}
+   ${ROCFFT_CLIENTS_DEVICE_LINK_LIBS} )
 
 include( ../../cmake/sqlite.cmake )
 target_link_libraries( rocfft-test PUBLIC ${ROCFFT_SQLITE_LIB} )
@@ -264,21 +303,6 @@ target_include_directories( rocfft-test PRIVATE ${sqlite_local_SOURCE_DIR} )
 
 set_property( TARGET rocfft-test APPEND PROPERTY LINK_LIBRARIES ${ROCFFT_SQLITE_LIB} )
 
-option( BUILD_CLIENTS_TESTS_OPENMP "Build tests with OpenMP" ON )
-
-if( BUILD_CLIENTS_TESTS_OPENMP )
-  if( CMAKE_CXX_COMPILER MATCHES ".*/hipcc$" )  
-    target_compile_options( rocfft-test PRIVATE -fopenmp )
-    target_link_libraries( rocfft-test PRIVATE -fopenmp -L${HIP_CLANG_ROOT}/lib -Wl,-rpath=${HIP_CLANG_ROOT}/lib )
-    target_include_directories( rocfft-test PRIVATE ${HIP_CLANG_ROOT}/include )
-  else()
-    if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-      target_compile_options( rocfft-test PRIVATE -fopenmp=libomp )
-      target_link_options( rocfft-test PRIVATE -fopenmp=libomp )
-    endif()
-  endif()
-endif()
-
 if(FFTW_MULTITHREAD)
   target_compile_options( rocfft-test PRIVATE -DFFTW_MULTITHREAD )
 endif( )
@@ -330,7 +354,18 @@ if( ROCFFT_MPI_ENABLE )
   # normal and dynamic-loading MPI worker processes
   foreach(worker rocfft_mpi_worker dyna_rocfft_mpi_worker)
     add_executable( ${worker} rocfft_mpi_worker.cpp )
-    target_compile_options( ${worker} PRIVATE -fopenmp )
+
+    if( BUILD_CLIENTS_TESTS_OPENMP )
+      set_target_properties( ${worker} PROPERTIES
+         BUILD_RPATH "${BUILD_RPATH}"
+      )
+      set_target_properties( ${worker} PROPERTIES
+        INSTALL_RPATH "${INSTALL_RPATH}"
+      )
+    endif()
+    if( BUILD_FFTW  OR NOT FFTW_FOUND )
+      add_dependencies( ${worker} fftw_double fftw_single )
+    endif()
     target_include_directories( ${worker}
       PRIVATE
       ${CMAKE_BINARY_DIR}/include
@@ -341,8 +376,8 @@ if( ROCFFT_MPI_ENABLE )
     target_compile_options( ${worker} PRIVATE ${WARNING_FLAGS} )
 
   if ( ROCFFT_CRAY_MPI_ENABLE )
-      target_link_libraries( ${worker}
-      -fopenmp
+    target_link_libraries( ${worker}
+      OpenMP::OpenMP_CXX 
       hip::hiprand
       hip::device
       MPI::MPI_CXX
@@ -355,7 +390,7 @@ if( ROCFFT_MPI_ENABLE )
 	${MPI_LIBDIR}/../../../../gtl/lib )
     else()
     target_link_libraries( ${worker}
-      -fopenmp
+      OpenMP::OpenMP_CXX 
       hip::hiprand
       hip::device
       MPI::MPI_CXX
@@ -382,3 +417,49 @@ if( ROCFFT_MPI_ENABLE )
   )
 
 endif()
+
+set(COVERAGE_TEST_OPTIONS "--smoketest;--gtest_filter=-*call*" CACHE STRING "Command line arguments for rocfft-test when generating a code coverage report")
+
+if(BUILD_CODE_COVERAGE)
+  # Coverage won't work in a standalone build of the tests, as we can't
+  # guarantee the library was built with coverage enabled
+  if( NOT TARGET rocfft )
+    message( FATAL_ERROR "BUILD_CODE_COVERAGE requires building from the root of rocFFT" )
+  endif()
+
+  add_custom_target(
+    code_cov_tests
+    DEPENDS rocfft-test rocfft_rtc_helper
+    COMMAND ${CMAKE_COMMAND} -E rm -rf ./coverage-report
+    COMMAND ${CMAKE_COMMAND} -E make_directory ./coverage-report/profraw
+    COMMAND ${CMAKE_COMMAND} -E env LLVM_PROFILE_FILE="./coverage-report/profraw/rocfft-coverage_%p.profraw" GTEST_LISTENER=NO_PASS_LINE_IN_LOG $<TARGET_FILE:rocfft-test> --precompile=rocfft-test-precompile.db ${COVERAGE_TEST_OPTIONS}
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+  )
+
+  find_program(
+    LLVM_PROFDATA
+    llvm-profdata
+    REQUIRED
+    HINTS ${ROCM_PATH}/llvm/bin
+    PATHS /opt/rocm/llvm/bin
+  )
+
+  find_program(
+    LLVM_COV
+    llvm-cov
+    REQUIRED
+    HINTS ${ROCM_PATH}/llvm/bin
+    PATHS /opt/rocm/llvm/bin
+  )
+
+  add_custom_target(
+    coverage
+    DEPENDS code_cov_tests
+    COMMAND ${LLVM_PROFDATA} merge -sparse ./coverage-report/profraw/rocfft-coverage_*.profraw -o ./coverage-report/rocfft.profdata
+    COMMAND ${LLVM_COV} report -object ./library/src/librocfft.so -instr-profile=./coverage-report/rocfft.profdata
+    COMMAND ${LLVM_COV} show -object ./library/src/librocfft.so -instr-profile=./coverage-report/rocfft.profdata -format=html -output-dir=coverage-report
+    COMMAND ${LLVM_COV} export -object ./library/src/librocfft.so -instr-profile=./coverage-report/rocfft.profdata -format=lcov > ./coverage-report/coverage.info
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+  )
+
+endif()
diff --git a/clients/tests/accuracy_test.cpp b/clients/tests/accuracy_test.cpp
index a3758a6..addaca1 100644
--- a/clients/tests/accuracy_test.cpp
+++ b/clients/tests/accuracy_test.cpp
@@ -230,7 +230,7 @@ __host__ __device__ static void store_callback_round_trip_inverse(
     Tdata* output, size_t offset, Tdata element, void* cbdata, void* sharedMem)
 {
     auto testdata = static_cast<callback_test_data*>(cbdata);
-    // add scalar to each element
+    // divide each element by scalar
     if(output == testdata->base)
     {
         output[offset] = element / testdata->scalar;
diff --git a/clients/tests/accuracy_test_3D.cpp b/clients/tests/accuracy_test_3D.cpp
index 37c80ca..d4e3e43 100644
--- a/clients/tests/accuracy_test_3D.cpp
+++ b/clients/tests/accuracy_test_3D.cpp
@@ -255,17 +255,22 @@ INSTANTIATE_TEST_SUITE_P(partial_pass_3D,
                                                              false)),
                          accuracy_test::TestName);
 
-INSTANTIATE_TEST_SUITE_P(partial_pass_3D_callback,
-                         accuracy_test,
-                         ::testing::ValuesIn(param_generator(test_prob,
-                                                             partial_pass_adhoc_3D,
-                                                             precision_range_sp_dp,
-                                                             partial_pass_batch_range_3D,
-                                                             stride_range,
-                                                             stride_range,
-                                                             ioffset_range_zero,
-                                                             ooffset_range_zero,
-                                                             place_range,
-                                                             false,
-                                                             true)),
-                         accuracy_test::TestName);
+INSTANTIATE_TEST_SUITE_P(
+#ifdef WIN32
+    DISABLED_partial_pass_3D_callback,
+#else
+    partial_pass_3D_callback,
+#endif
+    accuracy_test,
+    ::testing::ValuesIn(param_generator(test_prob,
+                                        partial_pass_adhoc_3D,
+                                        precision_range_sp_dp,
+                                        partial_pass_batch_range_3D,
+                                        stride_range,
+                                        stride_range,
+                                        ioffset_range_zero,
+                                        ooffset_range_zero,
+                                        place_range,
+                                        false,
+                                        true)),
+    accuracy_test::TestName);
diff --git a/clients/tests/accuracy_test_callback.cpp b/clients/tests/accuracy_test_callback.cpp
index 631a974..57c3244 100644
--- a/clients/tests/accuracy_test_callback.cpp
+++ b/clients/tests/accuracy_test_callback.cpp
@@ -104,22 +104,27 @@ const static std::vector<std::vector<size_t>> ooffset_range = {{0, 0}, {1, 1}};
 auto forward_transform_types
     = {fft_transform_type_complex_forward, fft_transform_type_real_forward};
 
-INSTANTIATE_TEST_SUITE_P(callback,
-                         accuracy_test,
-                         ::testing::ValuesIn(param_generator_base(test_prob,
-                                                                  forward_transform_types,
-                                                                  callback_sizes,
-                                                                  precision_range_sp_dp,
-                                                                  batch_range,
-                                                                  generate_types,
-                                                                  stride_range,
-                                                                  stride_range,
-                                                                  ioffset_range_zero,
-                                                                  ooffset_range_zero,
-                                                                  place_range,
-                                                                  false,
-                                                                  true)),
-                         accuracy_test::TestName);
+INSTANTIATE_TEST_SUITE_P(
+#ifdef WIN32
+    DISABLED_callback_no_offset,
+#else
+    callback,
+#endif
+    accuracy_test,
+    ::testing::ValuesIn(param_generator_base(test_prob,
+                                             forward_transform_types,
+                                             callback_sizes,
+                                             precision_range_sp_dp,
+                                             batch_range,
+                                             generate_types,
+                                             stride_range,
+                                             stride_range,
+                                             ioffset_range_zero,
+                                             ooffset_range_zero,
+                                             place_range,
+                                             false,
+                                             true)),
+    accuracy_test::TestName);
 
 INSTANTIATE_TEST_SUITE_P(DISABLED_callback,
                          accuracy_test,
diff --git a/clients/tests/accuracy_test_checkstride.cpp b/clients/tests/accuracy_test_checkstride.cpp
index 0f6b7c6..898497c 100644
--- a/clients/tests/accuracy_test_checkstride.cpp
+++ b/clients/tests/accuracy_test_checkstride.cpp
@@ -70,7 +70,11 @@ inline auto param_checkstride()
                 for(const auto& types :
                     generate_types(trans_type, {fft_placement_notinplace}, true))
                 {
+#ifdef WIN32
+                    for(bool callback : {false})
+#else
                     for(bool callback : {true, false})
+#endif
                     {
                         // callbacks don't work for planar
                         bool is_planar = std::get<2>(types) == fft_array_type_complex_planar
diff --git a/clients/tests/accuracy_tests_range.h b/clients/tests/accuracy_tests_range.h
index 103a97a..6b71b27 100644
--- a/clients/tests/accuracy_tests_range.h
+++ b/clients/tests/accuracy_tests_range.h
@@ -167,7 +167,15 @@ const static std::vector<size_t> inner_batch_3D_batch_range = {3, 2, 1};
 // partial pass test problems
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-const static std::vector<std::vector<size_t>> partial_pass_adhoc_3D       = {{64, 64, 64}};
-const static std::vector<size_t>              partial_pass_batch_range_3D = {1, 5, 10, 20, 50};
+const static std::vector<std::vector<size_t>> partial_pass_adhoc_3D = {
+    {64, 64, 128},
+    {64, 64, 64},
+    {64, 64, 52},
+    {60, 60, 60},
+    {32, 32, 128},
+    {32, 32, 64},
+    {64, 32, 128},
+};
+const static std::vector<size_t> partial_pass_batch_range_3D = {1, 5, 10, 20, 50};
 
 #endif // ACCURACY_TESTS_RANGE_H
\ No newline at end of file
diff --git a/clients/tests/buffer_hash_test.cpp b/clients/tests/buffer_hash_test.cpp
index 8d4831d..47095e2 100644
--- a/clients/tests/buffer_hash_test.cpp
+++ b/clients/tests/buffer_hash_test.cpp
@@ -19,6 +19,7 @@
 // THE SOFTWARE.
 
 #include "../../shared/fft_hash.h"
+#include "../../shared/params_gen.h"
 #include "../../shared/rocfft_params.h"
 #include <algorithm>
 #include <chrono>
@@ -29,7 +30,7 @@
 
 static void set_params(const fft_precision precision, fft_params& param)
 {
-    std::vector<size_t> blengths = {16777216};
+    std::vector<size_t> blengths = {131072};
 
     std::vector<size_t> unit_strides = {1};
 
@@ -357,6 +358,12 @@ static void run_test(const rocfft_params& params)
 
 TEST(rocfft_UnitTest, buffer_hashing_half)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     rocfft_params params;
     set_params(fft_precision_half, params);
 
@@ -372,6 +379,13 @@ TEST(rocfft_UnitTest, buffer_hashing_half)
 
 TEST(rocfft_UnitTest, buffer_hashing_single)
 {
+
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     rocfft_params params;
     set_params(fft_precision_single, params);
 
@@ -387,6 +401,13 @@ TEST(rocfft_UnitTest, buffer_hashing_single)
 
 TEST(rocfft_UnitTest, buffer_hashing_double)
 {
+
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     rocfft_params params;
     set_params(fft_precision_double, params);
 
diff --git a/clients/tests/callback_change_type.cpp b/clients/tests/callback_change_type.cpp
index 4a06a0f..24d4863 100644
--- a/clients/tests/callback_change_type.cpp
+++ b/clients/tests/callback_change_type.cpp
@@ -70,23 +70,28 @@ std::vector<std::vector<size_t>> callback_type_sizes = {{4}, {60}, {122}, {220},
 // the input can't be any smaller than what rocFFT thinks it is,
 // because the overwrite will fail.
 const static std::vector<std::vector<size_t>> stride_range = {{1}};
-INSTANTIATE_TEST_SUITE_P(callback,
-                         change_type,
-                         ::testing::ValuesIn(param_generator_base(
-                             test_prob,
-                             {fft_transform_type_complex_forward, fft_transform_type_real_forward},
-                             callback_type_sizes,
-                             {fft_precision_single},
-                             {1},
-                             generate_types,
-                             stride_range,
-                             stride_range,
-                             {{0, 0}},
-                             {{0, 0}},
-                             {fft_placement_notinplace},
-                             false,
-                             false)),
-                         accuracy_test::TestName);
+INSTANTIATE_TEST_SUITE_P(
+#ifdef WIN32
+    DISABLED_callback,
+#else
+    callback,
+#endif
+    change_type,
+    ::testing::ValuesIn(param_generator_base(test_prob,
+                                             {fft_transform_type_complex_forward,
+                                              fft_transform_type_real_forward},
+                                             callback_type_sizes,
+                                             {fft_precision_single},
+                                             {1},
+                                             generate_types,
+                                             stride_range,
+                                             stride_range,
+                                             {{0, 0}},
+                                             {{0, 0}},
+                                             {fft_placement_notinplace},
+                                             false,
+                                             false)),
+    accuracy_test::TestName);
 
 // run an out-of-place transform that casts input from short to float
 TEST_P(change_type, short_to_float)
diff --git a/clients/tests/default_callbacks_test.cpp b/clients/tests/default_callbacks_test.cpp
index 7c782aa..7ade249 100644
--- a/clients/tests/default_callbacks_test.cpp
+++ b/clients/tests/default_callbacks_test.cpp
@@ -28,6 +28,7 @@
 
 #include "../../shared/fftw_transform.h"
 #include "../../shared/hip_object_wrapper.h"
+#include "../../shared/params_gen.h"
 #include "../../shared/rocfft_params.h"
 #include "rocfft/rocfft.h"
 
@@ -409,8 +410,15 @@ struct Test_Callback
 // complex data inputs and having only a load callback set.
 // -------------------------------------------------------------------
 
+#ifndef WIN32
 TEST(rocfft_UnitTest, default_load_callback_complex_single)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     TEST_CALLBACK_CHECK_ASAN;
     Test_Callback test(256,
                        1,
@@ -422,6 +430,12 @@ TEST(rocfft_UnitTest, default_load_callback_complex_single)
 
 TEST(rocfft_UnitTest, default_load_callback_complex_double)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     TEST_CALLBACK_CHECK_ASAN;
     Test_Callback test(512,
                        1,
@@ -433,6 +447,12 @@ TEST(rocfft_UnitTest, default_load_callback_complex_double)
 
 TEST(rocfft_UnitTest, default_load_callback_real_single)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     TEST_CALLBACK_CHECK_ASAN;
     Test_Callback test(1024,
                        1,
@@ -444,6 +464,12 @@ TEST(rocfft_UnitTest, default_load_callback_real_single)
 
 TEST(rocfft_UnitTest, default_load_callback_real_double)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     TEST_CALLBACK_CHECK_ASAN;
     Test_Callback test(2048,
                        1,
@@ -460,6 +486,12 @@ TEST(rocfft_UnitTest, default_load_callback_real_double)
 
 TEST(rocfft_UnitTest, default_store_callback_complex_single)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     TEST_CALLBACK_CHECK_ASAN;
     Test_Callback test(256,
                        1,
@@ -471,6 +503,12 @@ TEST(rocfft_UnitTest, default_store_callback_complex_single)
 
 TEST(rocfft_UnitTest, default_store_callback_complex_double)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     TEST_CALLBACK_CHECK_ASAN;
     Test_Callback test(512,
                        1,
@@ -482,6 +520,12 @@ TEST(rocfft_UnitTest, default_store_callback_complex_double)
 
 TEST(rocfft_UnitTest, default_store_callback_real_single)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     TEST_CALLBACK_CHECK_ASAN;
     Test_Callback test(1024,
                        1,
@@ -493,6 +537,12 @@ TEST(rocfft_UnitTest, default_store_callback_real_single)
 
 TEST(rocfft_UnitTest, default_store_callback_real_double)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     TEST_CALLBACK_CHECK_ASAN;
     Test_Callback test(2048,
                        1,
@@ -501,3 +551,4 @@ TEST(rocfft_UnitTest, default_store_callback_real_double)
                        DefaultCallbackType::STORE,
                        8);
 }
+#endif
diff --git a/clients/tests/gtest_main.cpp b/clients/tests/gtest_main.cpp
index 3d3de51..aff9dc1 100644
--- a/clients/tests/gtest_main.cpp
+++ b/clients/tests/gtest_main.cpp
@@ -53,11 +53,14 @@
 int verbose;
 
 // User-defined random seed
-size_t random_seed;
+size_t             random_seed;
+std::random_device default_seed_dev;
 // Overall probability of running conventional tests
 double test_prob;
 // Probability of running tests from the emulation suite
 double emulation_prob;
+// Probability of running unit tests
+double unittest_prob;
 // Modifier for probability of running tests with complex interleaved data
 double complex_interleaved_prob_factor;
 // Modifier for probability of running tests with real data
@@ -81,6 +84,9 @@ size_t ramgb;
 // Device memory limitation for tests (GiB):
 size_t vramgb;
 
+// Number of hip devices to use.
+int ngpus{};
+
 // Allow skipping tests if there is a runtime error
 bool skip_runtime_fails;
 // But count the number of failures
@@ -166,11 +172,8 @@ void init_gtest_flags()
     std::swap(temp_list_tests, testing::GTEST_FLAG(list_tests));
 }
 
-void precompile_test_kernels(const std::string& precompile_file)
+std::vector<std::string> tokens_to_run()
 {
-    std::cout << "precompiling test kernels...\n";
-    WorkQueue<std::string> tokenQueue;
-
     init_gtest_flags();
 
     std::vector<std::string> tokens;
@@ -218,6 +221,15 @@ void precompile_test_kernels(const std::string& precompile_file)
             }
         }
     }
+    return tokens;
+}
+
+void precompile_test_kernels(const std::string& precompile_file)
+{
+    std::cout << "precompiling test kernels...\n";
+    WorkQueue<std::string> tokenQueue;
+
+    auto tokens = tokens_to_run();
 
     std::random_device dev;
     std::mt19937       dist(dev());
@@ -306,24 +318,25 @@ int main(int argc, char* argv[])
         "      HP - hermitian planar\n"
         "\n"
         "Usage"};
-
-    // Override CLI11 help to print after later CLI11 options that are defined, and allow gtest's
-    // help.
-    // After removing the stage-1 options, individual options are set to null (even if set), but we
-    // can still capture the behaviour by using a flag.
-
-    for(auto opt : app.get_options())
-    {
-        app.remove_option(opt);
-    }
+    // Override CLI11 help to print it along gtest's help
+    app.set_help_flag("");
+    const auto opt_help = app.add_flag("-h, --help", "Produces this help message");
     app.add_option("-v, --verbose", verbose, "Print out detailed information for the tests")
         ->default_val(0);
     app.add_option("--nrand", n_random_tests, "Number of extra randomized tests")->default_val(0);
+
+    app.add_option("--ngpus", ngpus, "Number of GPUs to use per rank")
+        ->default_val(-1)
+        ->check(CLI::NonNegativeNumber);
+    app.add_option("--gpus", n_random_tests, "Number of extra randomized tests")->default_val(0);
     app.add_option("--test_prob", test_prob, "Probability of running individual tests")
         ->default_val(1.0)
         ->check(CLI::Range(0.0, 1.0));
+    app.add_option("--unittest_prob", unittest_prob, "Probability of running individual unit tests")
+        ->default_val(1.0)
+        ->check(CLI::Range(0.0, 1.0));
     app.add_option(
-           "--emulation_prob", test_prob, "Probability of running individual emulation tests")
+           "--emulation_prob", emulation_prob, "Probability of running individual emulation tests")
         ->default_val(1.0)
         ->check(CLI::Range(0.0, 1.0));
     app.add_option("--real_prob",
@@ -411,7 +424,7 @@ int main(int argc, char* argv[])
             if(mp_lib == fft_params::fft_mp_lib_none)
             {
                 std::cout << "--mp_launch requires an mp library (see mp_lib in --help).\n";
-                std::exit(-1);
+                std::exit(EXIT_FAILURE);
             }
         })
         ->needs("--mp_lib");
@@ -420,8 +433,9 @@ int main(int argc, char* argv[])
         ->each([&](const std::string&) {
             // The objective is to have an test that takes about 5 minutes, so just set the
             // probability per test to a small value to achieve this result.
-            test_prob      = 0.001;
-            emulation_prob = 0.01;
+            test_prob      = 0.0005;
+            emulation_prob = 0.005;
+            unittest_prob  = 0.2;
             n_random_tests = 10;
         });
 
@@ -429,53 +443,8 @@ int main(int argc, char* argv[])
         manual_params.run_callbacks = true;
     });
 
-    {
-        // We explicitly scope opt_seed so that the object falls out of scope before the final
-        // parsing of the command line arguments.  Otherwise, the second parsing would mark the
-        // option as not having been specified, which can get rather confusing.
-
-        auto opt_seed = app.add_option(
-            "--seed", random_seed, "Random seed; if unset, use an actual random seed");
-
-        // Try parsing initial args that will be used to configure tests.
-        // Allow extras to pass on gtest and rocFFT arguments without error.
-        app.allow_extras();
-        try
-        {
-            app.parse(argc, argv);
-        }
-        catch(const CLI::ParseError& e)
-        {
-            return app.exit(e);
-        }
-
-        if(!*opt_seed)
-        {
-            std::cout << "Generating random seed: ";
-            std::random_device dev;
-            random_seed = dev();
-            std::cout << random_seed << "\n";
-        }
-    }
-
-    app.set_help_flag("");
-    auto opt_help = app.add_flag("-h, --help", "Produces this help message");
-
-    std::vector<std::string> remaining_args = app.remaining();
-    // Google test ignores the first element, so add something there so that it parses all of hte
-    // arguments that we want it to parse.:
-    remaining_args.insert(remaining_args.begin(), argv0);
-    // NB: If we initialize gtest first, then it removes all of its own command-line
-    // arguments and sets argc and argv correctly;
-    std::vector<char*> carg;
-    for(std::string& s : remaining_args)
-    {
-        carg.push_back(&s[0]);
-    }
-    carg.push_back(NULL);
-    decltype(argc) cargc = carg.size() - 1;
-    ::testing::InitGoogleTest(&cargc, carg.data());
-
+    app.add_option("--seed", random_seed, "Random seed; if unset, use an actual random seed")
+        ->default_val(default_seed_dev());
     // Filename for fftw and fftwf wisdom.
     std::string fftw_wisdom_filename;
 
@@ -488,6 +457,9 @@ int main(int argc, char* argv[])
     // Full path to bitwise repro database file
     std::string repro_db_path;
 
+    // Bool option to just print tokens and exit
+    bool printtokens{false};
+
     // Declare the supported options. Some option pointers are declared to track passed opts.
     app.add_flag("--version", "Print queryable version information from the rocfft library")
         ->each([](const std::string&) {
@@ -515,6 +487,11 @@ int main(int argc, char* argv[])
                      "forward\n3) real inverse")
         ->default_val(fft_transform_type_complex_forward);
     non_token
+        ->add_option("--auto_allocation",
+                     manual_params.auto_allocate,
+                     "rocFFT's auto-allocation behavior: \"on\", \"off\", or \"default\"")
+        ->default_val("default");
+    non_token
         ->add_option("--precision",
                      manual_params.precision,
                      "Transform precision: single (default), double, half")
@@ -576,6 +553,7 @@ int main(int argc, char* argv[])
                    precompile_file,
                    "Precompile kernels to a file for all test cases before running tests")
         ->default_val("");
+    app.add_flag("--printtokens", printtokens, "Print test tokens to scheduled to be run and exit");
     // Default value is set in fft_params.h based on if device-side PRNG was enabled.
     app.add_option("-g, --inputGen",
                    manual_params.igen,
@@ -584,36 +562,57 @@ int main(int argc, char* argv[])
                    "2) linearly-spaced sequence (device)\n"
                    "3) linearly-spaced sequence (host)");
 
-    // Parse rest of args and catch any errors here
+    // Try parsing initial args that will be used to configure tests
+    // Allow extras to pass on gtest arguments without error
+    app.allow_extras();
     try
     {
-        app.parse(cargc, carg.data());
+        app.parse(argc, argv);
     }
     catch(const CLI::ParseError& e)
     {
         return app.exit(e);
     }
 
+    // extract remaining arguments for subsequent gtest initialization
+    std::vector<std::string> remaining_args = app.remaining();
+    std::string              gtest_help_opt = "--help";
+    // NB: If we initialize gtest first, then it removes all of its own command-line
+    // arguments and sets argc and argv correctly;
+    std::vector<char*> gtest_argv;
+    gtest_argv.insert(gtest_argv.begin(), argv[0]);
+    for(std::string& s : remaining_args)
+    {
+        gtest_argv.push_back(&s[0]);
+    }
+    if(*opt_help)
+    {
+        // make sure gtest prints its help as well
+        gtest_argv.push_back(&gtest_help_opt[0]);
+    }
+    gtest_argv.push_back(NULL);
+    decltype(argc) gtest_argc = gtest_argv.size() - 1;
+    ::testing::InitGoogleTest(&gtest_argc, gtest_argv.data()); // gtest-relevant args are removed
+
     if(*opt_help)
     {
         std::cout << app.help() << "\n";
         return EXIT_SUCCESS;
     }
-
-    // Ensure there are no leftover options used by neither gtest nor CLI11
-    const auto leftover_args = app.remaining();
-    if(!leftover_args.empty())
+    // no help was used, gtest_argc is expected to be 1 at this point. If not, some of the
+    // used options were not recognized at all
+    if(gtest_argc > 1)
     {
         std::cout << "Unrecognised option(s) found:\n  ";
-        for(auto i : leftover_args)
-            std::cout << i << " ";
+        for(auto i = 1; i < gtest_argc; i++)
+            std::cout << gtest_argv[i] << " ";
         std::cout << "\nRun with --help for more information.\n";
         return EXIT_FAILURE;
     }
 
     std::cout << "half epsilon: " << half_epsilon << "\tsingle epsilon: " << single_epsilon
-              << "\tdouble epsilon: " << double_epsilon << "\n";
-    std::cout << "Random seed: " << random_seed << "\n";
+              << "\tdouble epsilon: " << double_epsilon << std::endl;
+    std::cout << "Random seed: " << random_seed << std::endl;
 
     // If precompiling, tell rocFFT to use the specified cache file
     // to write kernels to
@@ -628,9 +627,11 @@ int main(int argc, char* argv[])
     }
 
     rocfft_setup();
-    char v[256];
-    rocfft_get_version_string(v, 256);
-    std::cout << "rocFFT version: " << v << "\n";
+    {
+        char v[256];
+        rocfft_get_version_string(v, 256);
+        std::cout << "rocFFT version: " << v << std::endl;
+    }
 
 #ifdef FFTW_MULTITHREAD
     fftw_init_threads();
@@ -641,6 +642,7 @@ int main(int argc, char* argv[])
 
     // Set host memory limit from command-line options
     host_memory::singleton().set_limit_gbytes(ramgb);
+    std::cout << "Host memory limit: " << ramgb << " GiB" << std::endl;
 
     if(use_fftw_wisdom)
     {
@@ -693,7 +695,7 @@ int main(int argc, char* argv[])
 
     if(!test_token.empty())
     {
-        std::cout << "Reading fft params from token:\n" << test_token << "\n";
+        std::cout << "Reading fft params from token:\n" << test_token << std::endl;
 
         try
         {
@@ -701,8 +703,8 @@ int main(int argc, char* argv[])
         }
         catch(...)
         {
-            std::cout << "Unable to parse token.\n";
-            return 1;
+            std::cout << "Unable to parse token." << std::endl;
+            return EXIT_FAILURE;
         }
     }
     else
@@ -729,6 +731,17 @@ int main(int argc, char* argv[])
     if(!precompile_file.empty())
         precompile_test_kernels(precompile_file);
 
+    if(printtokens)
+    {
+        std::cout << "Tokens:" << std::endl;
+        const auto tokens = tokens_to_run();
+        for(const auto& token : tokens)
+        {
+            std::cout << token << std::endl;
+        }
+        return EXIT_SUCCESS;
+    }
+
     auto retval = RUN_ALL_TESTS();
 
     if(use_fftw_wisdom)
@@ -749,7 +762,8 @@ int main(int argc, char* argv[])
     const auto test_minutes
         = std::chrono::duration_cast<std::chrono::minutes>(test_duration - test_hours);
     std::cout << "Test suite took " << test_hours.count() << " hours " << test_minutes.count()
-              << " minutes\n\n";
+              << " minutes\n"
+              << std::endl;
 
     std::cout << "half precision max l-inf epsilon: " << max_linf_eps_half << "\n";
     std::cout << "half precision max l2 epsilon:     " << max_l2_eps_half << "\n";
@@ -758,8 +772,12 @@ int main(int argc, char* argv[])
     std::cout << "double precision max l-inf epsilon: " << max_linf_eps_double << "\n";
     std::cout << "double precision max l2 epsilon:     " << max_l2_eps_double << "\n";
     std::cout << "Number of runtime issues: " << n_hip_failures << "\n";
+    std::cout << "Number of successful tests: "
+              << ::testing::UnitTest::GetInstance()->successful_test_count() << "\n";
+    std::cout << "Number of skipped tests: "
+              << ::testing::UnitTest::GetInstance()->skipped_test_count() << "\n";
 
-    std::cout << "\nRandom seed: " << random_seed << "\n";
+    std::cout << "\nRandom seed: " << random_seed << std::endl;
 
     return retval;
 }
diff --git a/clients/tests/hermitian_test.cpp b/clients/tests/hermitian_test.cpp
index 8a17f6d..6c72b25 100644
--- a/clients/tests/hermitian_test.cpp
+++ b/clients/tests/hermitian_test.cpp
@@ -20,6 +20,7 @@
 
 #include "../../shared/accuracy_test.h"
 #include "../../shared/gpubuf.h"
+#include "../../shared/params_gen.h"
 #include "../../shared/rocfft_params.h"
 #include "../samples/rocfft/examplekernels.h"
 #include "../samples/rocfft/exampleutils.h"
@@ -171,12 +172,24 @@ void run_1D_hermitian_test(size_t length)
 // test a case that's small enough that it only needs one kernel
 TEST(rocfft_UnitTest, 1D_hermitian_single_small)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     run_1D_hermitian_test(8);
 }
 
 // test a case that's big enough that it needs multiple kernels
 TEST(rocfft_UnitTest, 1D_hermitian_single_large)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     run_1D_hermitian_test(8192);
 }
 
@@ -198,6 +211,12 @@ std::string str(T begin, T end)
 // Test that the GPU Hermitian symmetrizer code produces the correct results.
 TEST(rocfft_UnitTest, gpu_symmetrizer)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     std::vector<std::vector<size_t>> lengths = {{4, 4, 3},
                                                 {5},
                                                 {8},
diff --git a/clients/tests/hipGraph_test.cpp b/clients/tests/hipGraph_test.cpp
index 34f7ed2..da0caa7 100644
--- a/clients/tests/hipGraph_test.cpp
+++ b/clients/tests/hipGraph_test.cpp
@@ -22,6 +22,7 @@
 #include "../../shared/arithmetic.h"
 #include "../../shared/gpubuf.h"
 #include "../../shared/hip_object_wrapper.h"
+#include "../../shared/params_gen.h"
 #include "../../shared/rocfft_against_fftw.h"
 #include "../../shared/rocfft_params.h"
 #include "rocfft/rocfft.h"
@@ -271,6 +272,12 @@ static void compare_data(const std::vector<rocfft_complex<float>>& original_host
 
 TEST(rocfft_UnitTest, hipGraph_execution)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     hipGraph_t     graph      = nullptr;
     hipGraphExec_t graph_exec = nullptr;
 
@@ -375,7 +382,7 @@ TEST(rocfft_UnitTest, hipGraph_execution)
         ASSERT_EQ(hipGraphLaunch(graph_exec, stream), hipSuccess);
 
     ASSERT_EQ(hipStreamSynchronize(stream), hipSuccess);
-    ASSERT_EQ(hipStreamDestroy(stream), hipSuccess);
+    stream.free();
 
     // check for correctness of the output data
     compare_data(host_mem_in, device_mem_out);
@@ -386,5 +393,5 @@ TEST(rocfft_UnitTest, hipGraph_execution)
     fill(host_mem_counter_modified.begin(), host_mem_counter_modified.end(), num_graph_launches);
     compare_data_exact_match<size_t>(other_stream, host_mem_counter_modified, device_mem_counter);
 
-    ASSERT_EQ(hipStreamDestroy(other_stream), hipSuccess);
+    other_stream.free();
 }
diff --git a/clients/tests/multi_device_test.cpp b/clients/tests/multi_device_test.cpp
index 9c4b476..3cc3958 100644
--- a/clients/tests/multi_device_test.cpp
+++ b/clients/tests/multi_device_test.cpp
@@ -49,20 +49,31 @@ enum SplitType
     PENCIL_3D,
 };
 
-std::vector<fft_params> param_generator_multi_gpu(const SplitType type)
+std::vector<fft_params> param_generator_multi_gpu(const SplitType type, const int ngpus)
 {
     int localDeviceCount = 0;
-    (void)hipGetDeviceCount(&localDeviceCount);
+    if(ngpus <= 0)
+    {
+        // Use the command-line option as a priority
+        if(hipGetDeviceCount(&localDeviceCount) != hipSuccess)
+        {
+            throw std::runtime_error("hipGetDeviceCount failed");
+        }
+
+        // Limit local device testing to 16 GPUs, as we have some
+        // bottlenecks with larger device counts that unreasonably slow
+        // down plan creation
+        localDeviceCount = std::min<int>(16, localDeviceCount);
+    }
+    else
+    {
+        localDeviceCount = ngpus;
+    }
 
     // need multiple devices or multiprocessing to test anything
     if(localDeviceCount < 2 && mp_lib == fft_params::fft_mp_lib_none)
         return {};
 
-    // limit local device testing to 16 GPUs, as we have some
-    // bottlenecks with larger device counts that unreasonably slow
-    // down plan creation
-    localDeviceCount = std::min<int>(16, localDeviceCount);
-
     auto params_complex = param_generator_complex(test_prob,
                                                   multi_gpu_sizes,
                                                   precision_range_sp_dp,
@@ -165,30 +176,30 @@ std::vector<fft_params> param_generator_multi_gpu(const SplitType type)
 // split both input and output on slowest FFT dim
 INSTANTIATE_TEST_SUITE_P(multi_gpu_slowest_dim,
                          accuracy_test,
-                         ::testing::ValuesIn(param_generator_multi_gpu(SLOW_INOUT)),
+                         ::testing::ValuesIn(param_generator_multi_gpu(SLOW_INOUT, ngpus)),
                          accuracy_test::TestName);
 
 // split slowest FFT dim only on input, or only on output
 INSTANTIATE_TEST_SUITE_P(multi_gpu_slowest_input_dim,
                          accuracy_test,
-                         ::testing::ValuesIn(param_generator_multi_gpu(SLOW_IN)),
+                         ::testing::ValuesIn(param_generator_multi_gpu(SLOW_IN, ngpus)),
                          accuracy_test::TestName);
 INSTANTIATE_TEST_SUITE_P(multi_gpu_slowest_output_dim,
                          accuracy_test,
-                         ::testing::ValuesIn(param_generator_multi_gpu(SLOW_OUT)),
+                         ::testing::ValuesIn(param_generator_multi_gpu(SLOW_OUT, ngpus)),
                          accuracy_test::TestName);
 
 // split input on slowest FFT and output on fastest, to minimize data
 // movement (only makes sense for rank-2 and higher FFTs)
 INSTANTIATE_TEST_SUITE_P(multi_gpu_slowin_fastout,
                          accuracy_test,
-                         ::testing::ValuesIn(param_generator_multi_gpu(SLOW_IN_FAST_OUT)),
+                         ::testing::ValuesIn(param_generator_multi_gpu(SLOW_IN_FAST_OUT, ngpus)),
                          accuracy_test::TestName);
 
 // 3D pencil decompositions
 INSTANTIATE_TEST_SUITE_P(multi_gpu_3d_pencils,
                          accuracy_test,
-                         ::testing::ValuesIn(param_generator_multi_gpu(PENCIL_3D)),
+                         ::testing::ValuesIn(param_generator_multi_gpu(PENCIL_3D, ngpus)),
                          accuracy_test::TestName);
 
 TEST(multi_gpu_validate, catch_validation_errors)
@@ -204,7 +215,7 @@ TEST(multi_gpu_validate, catch_validation_errors)
     for(auto type : all_split_types)
     {
         // gather all of the multi-GPU test cases
-        auto params = param_generator_multi_gpu(type);
+        auto params = param_generator_multi_gpu(type, ngpus);
 
         for(size_t i = 0; i < params.size(); ++i)
         {
@@ -284,3 +295,105 @@ TEST(multi_gpu_validate, catch_validation_errors)
         }
     }
 }
+
+static const auto multi_gpu_tokens = {
+    // clang-format off
+
+    // input bricks are not contiguous
+    "real_forward_len_160_160_160_single_op_batch_1_ifield_brick_lower_0_0_0_0_upper_1_80_160_160_stride_0_25920_162_1_dev_0_brick_lower_0_80_0_0_upper_1_160_160_160_stride_0_25920_162_1_rank_1_dev_1_ofield_brick_lower_0_0_0_0_upper_1_160_80_81_stride_0_6480_81_1_dev_0_brick_lower_0_0_80_0_upper_1_160_160_81_stride_0_6480_81_1_rank_1_dev_1",
+    // output bricks are not contiguous
+    "real_forward_len_160_160_160_single_op_batch_1_ifield_brick_lower_0_0_0_0_upper_1_80_160_160_stride_0_25600_160_1_dev_0_brick_lower_0_80_0_0_upper_1_160_160_160_stride_0_25600_160_1_rank_1_dev_1_ofield_brick_lower_0_0_0_0_upper_1_160_80_81_stride_0_6560_82_1_dev_0_brick_lower_0_0_80_0_upper_1_160_160_81_stride_0_6560_82_1_rank_1_dev_1",
+    // neither input nor output bricks are contiguous
+    "real_forward_len_160_160_160_single_op_batch_1_ifield_brick_lower_0_0_0_0_upper_1_80_160_160_stride_0_25920_162_1_dev_0_brick_lower_0_80_0_0_upper_1_160_160_160_stride_0_25920_162_1_rank_1_dev_1_ofield_brick_lower_0_0_0_0_upper_1_160_80_81_stride_0_6560_82_1_dev_0_brick_lower_0_0_80_0_upper_1_160_160_81_stride_0_6560_82_1_rank_1_dev_1",
+    // 1D multi-process batched in-place transform using 1 device per rank
+    "complex_forward_len_256_double_ip_batch_4_ifield_brick_lower_0_0_upper_4_128_stride_128_1_dev_0_brick_lower_0_128_upper_4_256_stride_128_1_rank_1_dev_1_ofield_brick_lower_0_0_upper_4_128_stride_128_1_dev_0_brick_lower_0_128_upper_4_256_stride_128_1_rank_1_dev_1",
+    // 2D multi-process out-of-place transform using 2 MPI ranks each with 2 GPUs
+    "complex_forward_len_128_256_single_op_batch_1_ifield_brick_lower_0_0_0_upper_1_128_64_stride_8192_64_1_dev_0_brick_lower_0_0_64_upper_1_128_128_stride_8192_64_1_rank_1_dev_1_brick_lower_0_0_128_upper_1_128_192_stride_8192_64_1_rank_0_dev_2_brick_lower_0_0_192_upper_1_128_256_stride_8192_64_1_rank_1_dev_3_ofield_brick_lower_0_0_0_upper_1_128_64_stride_8192_64_1_dev_0_brick_lower_0_0_64_upper_1_128_128_stride_8192_64_1_rank_1_dev_1_brick_lower_0_0_128_upper_1_128_192_stride_8192_64_1_rank_0_dev_2_brick_lower_0_0_192_upper_1_128_256_stride_8192_64_1_rank_1_dev_3",    
+    // 3D multi-process out-of-place transform using 2 MPI ranks each with 2 GPUs
+    "complex_forward_len_256_256_256_double_op_batch_1_ifield_brick_lower_0_0_0_0_upper_1_64_256_256_stride_4194304_65536_256_1_dev_0_brick_lower_0_64_0_0_upper_1_128_256_256_stride_4194304_65536_256_1_rank_0_dev_1_brick_lower_0_128_0_0_upper_1_192_256_256_stride_4194304_65536_256_1_rank_1_dev_2_brick_lower_0_192_0_0_upper_1_256_256_256_stride_4194304_65536_256_1_rank_1_dev_3_ofield_brick_lower_0_0_0_0_upper_1_256_256_64_stride_4194304_16384_64_1_dev_0_brick_lower_0_0_0_64_upper_1_256_256_128_stride_4194304_16384_64_1_rank_0_dev_1_brick_lower_0_0_0_128_upper_1_256_256_192_stride_4194304_16384_64_1_rank_1_dev_2_brick_lower_0_0_0_192_upper_1_256_256_256_stride_4194304_16384_64_1_rank_1_dev_3",
+    // 3D multi-process batched in-place transform using 2 MPI ranks each with 2 GPUs
+    "complex_forward_len_128_300_256_single_op_batch_4_ifield_brick_lower_0_0_0_0_upper_4_32_300_256_stride_2457600_76800_256_1_dev_0_brick_lower_0_32_0_0_upper_4_64_300_256_stride_2457600_76800_256_1_rank_1_dev_1_brick_lower_0_64_0_0_upper_4_96_300_256_stride_2457600_76800_256_1_rank_0_dev_2_brick_lower_0_96_0_0_upper_4_128_300_256_stride_2457600_76800_256_1_rank_1_dev_3_ofield_brick_lower_0_0_0_0_upper_4_128_300_64_stride_2457600_19200_64_1_dev_0_brick_lower_0_0_0_64_upper_4_128_300_128_stride_2457600_19200_64_1_rank_1_dev_1_brick_lower_0_0_0_128_upper_4_128_300_192_stride_2457600_19200_64_1_rank_0_dev_2_brick_lower_0_0_0_192_upper_4_128_300_256_stride_2457600_19200_64_1_rank_1_dev_3 ",
+
+    // clang-format on
+};
+
+std::vector<fft_params> param_generator_multi_gpu_adhoc()
+{
+    int localDeviceCount = 0;
+    if(ngpus <= 0)
+    {
+        // Use the command-line option as a priority
+        if(hipGetDeviceCount(&localDeviceCount) != hipSuccess)
+        {
+            throw std::runtime_error("hipGetDeviceCount failed");
+        }
+
+        // Limit local device testing to 16 GPUs, as we have some
+        // bottlenecks with larger device counts that unreasonably slow
+        // down plan creation
+        localDeviceCount = std::min<int>(16, localDeviceCount);
+    }
+    else
+    {
+        localDeviceCount = ngpus;
+    }
+
+    auto all_params = param_generator_token(test_prob, multi_gpu_tokens);
+
+    // check if fields use more bricks than we can support
+    auto too_many_bricks = [=](const std::vector<fft_params::fft_field>& fields, size_t maxBricks) {
+        for(const auto& f : fields)
+        {
+            if(f.bricks.size() > maxBricks)
+                return true;
+
+            // also remove a test case if it uses a numbered device
+            // that isn't available
+            if(std::any_of(f.bricks.begin(), f.bricks.end(), [=](const fft_params::fft_brick& b) {
+                   return b.device >= localDeviceCount;
+               }))
+                return true;
+        }
+        return false;
+    };
+
+    // remove test cases where we don't have enough ranks/devices for
+    // the number of bricks
+    all_params.erase(std::remove_if(all_params.begin(),
+                                    all_params.end(),
+                                    [=](const fft_params& params) {
+                                        size_t maxBricks = mp_lib == fft_params::fft_mp_lib_mpi
+                                                               ? mp_ranks
+                                                               : localDeviceCount;
+                                        return too_many_bricks(params.ifields, maxBricks)
+                                               || too_many_bricks(params.ofields, maxBricks);
+                                    }),
+                     all_params.end());
+
+    // set all bricks in a field to rank-0, to change an MPI test
+    // case to single-proc
+    auto set_rank_0 = [](std::vector<fft_params::fft_field>& fields) {
+        for(auto& f : fields)
+        {
+            for(auto& b : f.bricks)
+                b.rank = 0;
+        }
+    };
+
+    // modify the remaining test cases to use the current multi-GPU lib
+    for(auto& params : all_params)
+    {
+        params.mp_lib = mp_lib;
+        if(mp_lib == fft_params::fft_mp_lib_none)
+        {
+            set_rank_0(params.ifields);
+            set_rank_0(params.ofields);
+        }
+    }
+    return all_params;
+}
+
+INSTANTIATE_TEST_SUITE_P(multi_gpu_adhoc_token,
+                         accuracy_test,
+                         ::testing::ValuesIn(param_generator_multi_gpu_adhoc()),
+                         accuracy_test::TestName);
diff --git a/clients/tests/multithread_test.cpp b/clients/tests/multithread_test.cpp
index 5ec9a5f..3b6cd5e 100644
--- a/clients/tests/multithread_test.cpp
+++ b/clients/tests/multithread_test.cpp
@@ -21,6 +21,7 @@
 #include "../../shared/accuracy_test.h"
 #include "../../shared/gpubuf.h"
 #include "../../shared/hip_object_wrapper.h"
+#include "../../shared/params_gen.h"
 #include "../../shared/rocfft_against_fftw.h"
 #include "../../shared/rocfft_params.h"
 #include "rocfft/rocfft.h"
@@ -322,30 +323,66 @@ static void multistream_transform(size_t N, size_t dim, size_t num_streams)
 // fitting into e.g. 8 GB of GPU memory
 TEST(DISABLED_rocfft_UnitTest, simple_multithread_1D)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     multithread_transform(1048576, 1, 64);
 }
 
 TEST(DISABLED_rocfft_UnitTest, simple_multithread_2D)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     multithread_transform(1024, 2, 64);
 }
 
 TEST(DISABLED_rocfft_UnitTest, simple_multithread_3D)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     multithread_transform(128, 3, 40);
 }
 
 TEST(rocfft_UnitTest, simple_multistream_1D)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     multistream_transform(1048576, 1, 32);
 }
 
 TEST(rocfft_UnitTest, simple_multistream_2D)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     multistream_transform(1024, 2, 32);
 }
 
 TEST(rocfft_UnitTest, simple_multistream_3D)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     multistream_transform(128, 3, 32);
 }
diff --git a/clients/tests/unit_test.cpp b/clients/tests/unit_test.cpp
index 1b9b970..6ee83a2 100644
--- a/clients/tests/unit_test.cpp
+++ b/clients/tests/unit_test.cpp
@@ -23,10 +23,13 @@
 #include "../../shared/concurrency.h"
 #include "../../shared/environment.h"
 #include "../../shared/gpubuf.h"
+#include "../../shared/params_gen.h"
+#include "../../shared/precision_type.h"
 #include "../../shared/rocfft_complex.h"
 #include "hip/hip_runtime_api.h"
 #include <boost/scope_exit.hpp>
 #include <condition_variable>
+#include <cstdio>
 #include <cstdlib>
 #include <fstream>
 #include <gtest/gtest.h>
@@ -58,6 +61,12 @@ namespace fs = std::filesystem;
 
 TEST(rocfft_UnitTest, plan_description)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     rocfft_plan_description desc = nullptr;
     ASSERT_TRUE(rocfft_status_success == rocfft_plan_description_create(&desc));
 
@@ -106,6 +115,12 @@ TEST(rocfft_UnitTest, plan_description_reuse)
     // check that a plan description can be reused between different
     // plans, with different layout parameters for each.
 
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     // allocate plan description once
     rocfft_plan_description desc = nullptr;
     ASSERT_EQ(rocfft_plan_description_create(&desc), rocfft_status_success);
@@ -191,9 +206,92 @@ TEST(rocfft_UnitTest, plan_description_reuse)
     ASSERT_EQ(rocfft_plan_description_destroy(desc), rocfft_status_success);
 }
 
+// run a transform with all log levels enabled
+TEST(rocfft_UnitTest, log_levels)
+{
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
+    // clean up environment and temporary file when we exit
+    BOOST_SCOPE_EXIT_ALL(=)
+    {
+        rocfft_cleanup();
+        // re-init logs with default logging
+        rocfft_setup();
+    };
+    rocfft_cleanup();
+
+    // enumerate all known log levels and direct all of the logs to nowhere
+    EnvironmentSetTemp layer("ROCFFT_LAYER", std::to_string(0xffffffff).c_str());
+#ifdef WIN32
+    static const char* log_output = "NUL";
+#else
+    static const char* log_output   = "/dev/null";
+#endif
+    EnvironmentSetTemp log_trace_path("ROCFFT_LOG_TRACE_PATH", log_output);
+    EnvironmentSetTemp log_bench_path("ROCFFT_LOG_BENCH_PATH", log_output);
+    EnvironmentSetTemp log_profile_path("ROCFFT_LOG_PROFILE_PATH", log_output);
+    EnvironmentSetTemp log_plan_path("ROCFFT_LOG_PLAN_PATH", log_output);
+    EnvironmentSetTemp log_kernelio_path("ROCFFT_LOG_KERNELIO_PATH", log_output);
+    EnvironmentSetTemp log_rtc_path("ROCFFT_LOG_RTC_PATH", log_output);
+    EnvironmentSetTemp log_tuning_path("ROCFFT_LOG_TUNING_PATH", log_output);
+    EnvironmentSetTemp log_graph_path("ROCFFT_LOG_GRAPH_PATH", log_output);
+
+    rocfft_setup();
+
+    // Test single-kernel Bluestein and a multi-kernel plan
+    //
+    // TODO: add fused L1D Bluestein case like 8191, as that does weird
+    // things with buffers
+    for(const size_t length : {
+            37,
+            64,
+            32768,
+        })
+    {
+        for(const auto type : {rocfft_transform_type_complex_forward,
+                               rocfft_transform_type_real_forward,
+                               rocfft_transform_type_real_inverse})
+        {
+            for(const auto precision :
+                {rocfft_precision_single, rocfft_precision_double, rocfft_precision_half})
+            {
+                rocfft_plan plan = nullptr;
+                ASSERT_EQ(
+                    rocfft_plan_create(
+                        &plan, rocfft_placement_inplace, type, precision, 1, &length, 1, nullptr),
+                    rocfft_status_success);
+
+                // assume transform uses complex, will overallocate for real
+                // transforms but we only care about logging
+                gpubuf data_dev;
+                ASSERT_EQ(
+                    data_dev.alloc(element_size(precision, rocfft_array_type_complex_interleaved)
+                                   * length),
+                    hipSuccess);
+
+                void* data_dev_ptr = data_dev.data();
+                ASSERT_EQ(rocfft_execute(plan, &data_dev_ptr, nullptr, nullptr),
+                          rocfft_status_success);
+
+                rocfft_plan_destroy(plan);
+            }
+        }
+    }
+}
+
 // Check whether logs can be emitted from multiple threads properly
 TEST(rocfft_UnitTest, log_multithreading)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     static const int   NUM_THREADS          = 10;
     static const int   NUM_ITERS_PER_THREAD = 50;
     static const char* TRACE_FILE           = "trace.log";
@@ -321,18 +419,36 @@ void workmem_test(workmem_sizer sizer,
 // - library should allocate
 TEST(rocfft_UnitTest, workmem_missing)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     workmem_test([](size_t) { return 0; }, rocfft_status_success);
 }
 
 // check what happens if work memory is required but not enough is provided
 TEST(rocfft_UnitTest, workmem_small)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     workmem_test([](size_t requested) { return requested / 2; }, rocfft_status_invalid_work_buffer);
 }
 
 // hard to imagine this being a problem, but try giving too much as well
 TEST(rocfft_UnitTest, workmem_big)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     workmem_test([](size_t requested) { return requested * 2; }, rocfft_status_success);
 }
 
@@ -341,13 +457,25 @@ TEST(rocfft_UnitTest, workmem_big)
 // allocates
 TEST(rocfft_UnitTest, workmem_null)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     workmem_test([](size_t requested) { return requested; }, rocfft_status_success, true);
 }
 
 static const size_t RTC_PROBLEM_SIZE = 2304;
-// runtime compilation cache tests
-TEST(rocfft_UnitTest, rtc_cache)
+// runtime compilation cache tests main loop
+void rtc_cache_main()
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     // PRECONDITIONS
 
     // - set cache location to custom path, requires uninitializing
@@ -494,9 +622,27 @@ TEST(rocfft_UnitTest, rtc_cache)
     ASSERT_TRUE(fft_kernel_was_compiled());
 }
 
+// run the main body of rtc cache tests twice to uncover potential
+// problems with thread reuse between iterations
+TEST(rocfft_UnitTest, rtc_cache_iter_1)
+{
+    rtc_cache_main();
+}
+
+TEST(rocfft_UnitTest, rtc_cache_iter_2)
+{
+    rtc_cache_main();
+}
+
 // make sure cache API functions tolerate null pointers without crashing
 TEST(rocfft_UnitTest, rtc_cache_null)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     void*  buf     = nullptr;
     size_t buf_len = 0;
     ASSERT_EQ(rocfft_cache_serialize(nullptr, &buf_len), rocfft_status_invalid_arg_value);
@@ -509,6 +655,12 @@ TEST(rocfft_UnitTest, rtc_cache_null)
 // make sure RTC gracefully handles a helper process that crashes
 TEST(rocfft_UnitTest, rtc_helper_crash)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
 #ifdef WIN32
     char filename[MAX_PATH];
     GetModuleFileNameA(NULL, filename, MAX_PATH);
@@ -574,6 +726,12 @@ TEST(rocfft_UnitTest, rtc_helper_crash)
 
 TEST(rocfft_UnitTest, rtc_test_harness)
 {
+    if(hash_prob(random_seed, ::testing::UnitTest::GetInstance()->current_test_info()->name())
+       > unittest_prob)
+    {
+        GTEST_SKIP();
+    }
+
     // check that hipcc is available since this test requires it
     //
     // NOTE: using system() for launching subprocesses for simplicity
@@ -597,8 +755,17 @@ TEST(rocfft_UnitTest, rtc_test_harness)
 
     // extra scope to control lifetime of env vars
     {
-        // rtc test harness writes to system's temp directory
-        auto tmp_path = fs::temp_directory_path();
+        // create a temporary directory to hold all of the temp files
+        // that get created
+        const fs::path tmp_path = std::tmpnam(nullptr);
+        try
+        {
+            fs::create_directory(tmp_path);
+        }
+        catch(fs::filesystem_error& e)
+        {
+            GTEST_SKIP() << "unable to create temp dir for test harnesses: " << e.what();
+        }
 
         // activate writing of rtc test harnesses
         EnvironmentSetTemp env_harness("ROCFFT_DEBUG_GENERATE_KERNEL_HARNESS", "1");
@@ -613,17 +780,6 @@ TEST(rocfft_UnitTest, rtc_test_harness)
 
         rocfft_setup();
 
-        // ensure stale files from previous runs of this test won't cause
-        // problems - clean up any rocfft_kernel_harness_*.cpp files that
-        // might be left behind
-        for(const auto& entry : std::filesystem::directory_iterator{tmp_path})
-        {
-            auto filename = entry.path().filename();
-            if(filename.string().compare(0, 22, "rocfft_kernel_harness_") == 0
-               && filename.extension().string() == ".cpp")
-                fs::remove(entry);
-        }
-
         // construct a few different types of plans to try to get all
         // different kernels compiled
 
@@ -704,6 +860,19 @@ TEST(rocfft_UnitTest, rtc_test_harness)
 
         // check that all compiles succeeded
         for(const auto& file : files)
+        {
             ASSERT_EQ(file.second, 0);
+        }
+
+        // clean up temporary files
+        try
+        {
+            fs::remove_all(tmp_path);
+        }
+        catch(fs::filesystem_error&)
+        {
+            // this should work, but ignore errors as the build
+            // status is what matters for this test
+        }
     }
 }
diff --git a/cmake/sqlite.cmake b/cmake/sqlite.cmake
index 098be8f..2dc2a28 100644
--- a/cmake/sqlite.cmake
+++ b/cmake/sqlite.cmake
@@ -1,4 +1,4 @@
-# Copyright (C) 2024 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright (C) 2025 Advanced Micro Devices, Inc. All rights reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -20,35 +20,36 @@
 
 include( ExternalProject )
 
-# SQLite 3.36.0 enabled the backup API by default, which we need
-# for cache serialization.  We also want to use a static SQLite,
-# and distro static libraries aren't typically built
-# position-independent.
+# SQLite is used for rtc_cache. Require a safe baseline (>= 3.50.2).
+# Note: the backup API we rely on has been enabled by default since 3.36.0.
 option( SQLITE_USE_SYSTEM_PACKAGE "Use SQLite3 from find_package" OFF )
 
 if( SQLITE_USE_SYSTEM_PACKAGE )
-  find_package(SQLite3 3.36 REQUIRED)
+  # Require a safe baseline (fixes truncation/memory-corruption issues).
+  find_package(SQLite3 3.50.2 REQUIRED)
   list(APPEND static_depends PACKAGE SQLite3)
   set(ROCFFT_SQLITE_LIB SQLite::SQLite3)
 else()
   include( FetchContent )
 
-  if(DEFINED ENV{SQLITE_3_43_2_SRC_URL})
-    set(SQLITE_3_43_2_SRC_URL_INIT $ENV{SQLITE_3_43_2_SRC_URL})
+  # embed SQLite amalgamation (version 3.50.2 -> serial 3500200).
+  # allow override via environment variable for mirrors/airgapped builds.
+  if(DEFINED ENV{SQLITE_3_50_2_SRC_URL})
+    set(SQLITE_3_50_2_SRC_URL_INIT $ENV{SQLITE_3_50_2_SRC_URL})
   else()
-    set(SQLITE_3_43_2_SRC_URL_INIT https://www.sqlite.org/2023/sqlite-amalgamation-3430200.zip)
+    set(SQLITE_3_50_2_SRC_URL_INIT https://www.sqlite.org/2025/sqlite-amalgamation-3500200.zip)
   endif()
-  set(SQLITE_3_43_2_SRC_URL ${SQLITE_3_43_2_SRC_URL_INIT} CACHE STRING "Location of SQLite source code")
-  set(SQLITE_SRC_3_43_2_SHA3_256 af02b88cc922e7506c6659737560c0756deee24e4e7741d4b315af341edd8b40 CACHE STRING "SHA3-256 hash of SQLite source code")
+  set(SQLITE_3_50_2_SRC_URL ${SQLITE_3_50_2_SRC_URL_INIT} CACHE STRING "Location of SQLite source code")
+  set(SQLITE_SRC_3_50_2_SHA3_256 75c118e727ee6a9a3d2c0e7c577500b0c16a848d109027f087b915b671f61f8a CACHE STRING "SHA3-256 hash of SQLite source code")
 
-  # embed SQLite
+  # use extract timestamp for fetched files instead of timestamps in the archive
   if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.24)
-    # use extract timestamp for fetched files instead of timestamps in the archive
     cmake_policy(SET CMP0135 NEW)
   endif()
+
   FetchContent_Declare(sqlite_local
-    URL ${SQLITE_3_43_2_SRC_URL}
-    URL_HASH SHA3_256=${SQLITE_SRC_3_43_2_SHA3_256}
+    URL ${SQLITE_3_50_2_SRC_URL}
+    URL_HASH SHA3_256=${SQLITE_SRC_3_50_2_SHA3_256}
   )
   FetchContent_MakeAvailable(sqlite_local)
 
diff --git a/debian/changelog b/debian/changelog
index 4aea252..4c9901e 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,27 @@
+rocfft (7.1.0-0ubuntu1) resolute; urgency=medium
+
+  [Talha Can Havadar]
+  * New upstream version 7.1.0 (LP: #2139240)
+  * d/control: remove ppc64el builds (LP: #2134241)
+  * d/control: update b-d to use upstream llvm based toolchain
+  * d/gbp.conf: update debian branch to ubuntu/devel
+  * d/patches/fix-hiprtc-link.patch: is already upstreamed
+  * d/p/Extend-docs-conf.py-for-offline-build.patch: fix the hunk
+  * d/p/do-not-strictly-depend-on-sqlite3-v3.50.2.patch: no real hard
+    requirement for build to fail
+  * d/librocfft-dev.examples: removed from upstream
+  * Changes by Igor Luppi made on top of 6.4.3-1~exp1 listed below to keep
+    history intact
+
+  [Igor Luppi]
+  * d/rules: use GPU_TARGETS instead of deprecated AMDGPU_TARGETS
+  * d/control: remove libamdhip64-dev since hipcc-rocm is used
+  * d/control: update build-depends
+  * d/control: update maintainer field
+  * d/rules: fix FTBFS by adding -Wl,--gc-sections to flags
+
+ -- Talha Can Havadar <[e-mail]>  Fri, 23 Jan 2026 10:09:10 +0100
+
 rocfft (6.4.3-1) unstable; urgency=medium
 
   [ Cordell Bloor ]
diff --git a/debian/control b/debian/control
index a58bcfd..56faddd 100644
--- a/debian/control
+++ b/debian/control
@@ -5,25 +5,25 @@ Priority: optional
 Standards-Version: 4.7.2
 Vcs-Git: https://salsa.debian.org/rocm-team/rocfft.git
 Vcs-Browser: https://salsa.debian.org/rocm-team/rocfft
-Maintainer: Debian ROCm Team <[e-mail]>
-Uploaders: Cordell Bloor <[e-mail]>,
+Maintainer: Ubuntu Developers <[e-mail]>
+XSBC-Original-Maintainer: Debian ROCm Team <[e-mail]>
+Uploaders: Maxime Chambonnet <[e-mail]>,
+           Cordell Bloor <[e-mail]>,
            Christian Kastner <[e-mail]>,
            Kari Pahula <[e-mail]>
 Build-Depends: debhelper-compat (= 13),
                cmake,
-               hipcc (>= 5.6.1~),
-# end
-               libamd-comgr-dev (>= 6.0~),
-# ckk 2024-03-02: temporary until hipcc question is resolved:
-               libamdhip64-dev (>= 5.6.1~),
+               hipcc (>= 7.1.0~),
+               libamd-comgr-dev (>= 7.1.0~),
                libboost-program-options-dev,
                libfftw3-dev,
                libgtest-dev <!nocheck>,
-               libhsa-runtime-dev (>= 5.7.1~),
+               libhiprand-dev (>= 7.1.0~),
+               libhsa-runtime-dev (>= 7.1.0~),
                libsqlite3-dev,
-               pkg-rocm-tools (>= 0.9.0~exp3),
+               pkg-rocm-tools (>= 0.9.0),
                python3-dev,
-               rocm-cmake (>= 5.3.0)
+               rocm-cmake (>= 7.1.0)
 Build-Depends-Indep: dh-sequence-sphinxdoc <!nodoc>,
                      libjs-jquery <!nodoc>,
                      libjs-mathjax <!nodoc>,
@@ -36,7 +36,7 @@ Rules-Requires-Root: no
 
 Package: librocfft0
 Section: libs
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
 Multi-Arch: same
 XB-X-ROCm-GPU-Architecture: ${rocm:GPU-Architecture}
 Depends: ${misc:Depends}, ${shlibs:Depends}
@@ -53,7 +53,7 @@ Description: ROCm library for computing Fast Fourier Transforms - library
 
 Package: librocfft-dev
 Section: libdevel
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
 Depends: librocfft0 (= ${binary:Version}), ${misc:Depends}, ${shlibs:Depends}
 Recommends: libamdhip64-dev
 Suggests: librocfft-doc
@@ -70,7 +70,7 @@ Description: ROCm library for computing Fast Fourier Transforms - headers
 
 Package: librocfft0-tests
 Section: libdevel
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
 Build-Profiles: <!nocheck>
 Depends: librocfft0 (= ${binary:Version}), ${misc:Depends}, ${shlibs:Depends}
 Description: ROCm library for computing Fast Fourier Transforms - tests
diff --git a/debian/gbp.conf b/debian/gbp.conf
index 357a581..2f75208 100644
--- a/debian/gbp.conf
+++ b/debian/gbp.conf
@@ -1,5 +1,5 @@
 [DEFAULT]
-debian-branch = debian/unstable
+debian-branch = ubuntu/devel
 upstream-branch = upstream/latest
 pristine-tar = True
 
diff --git a/debian/librocfft-dev.examples b/debian/librocfft-dev.examples
deleted file mode 100644
index a8f30e1..0000000
--- a/debian/librocfft-dev.examples
+++ /dev/null
@@ -1 +0,0 @@
-docs/samples/*.cpp
diff --git a/debian/patches/Extend-docs-conf.py-for-offline-build.patch b/debian/patches/Extend-docs-conf.py-for-offline-build.patch
index be118d7..791856a 100644
--- a/debian/patches/Extend-docs-conf.py-for-offline-build.patch
+++ b/debian/patches/Extend-docs-conf.py-for-offline-build.patch
@@ -8,16 +8,14 @@ would cause the build to fail.
  docs/conf.py | 2 ++
  1 file changed, 2 insertions(+)
 
-diff --git a/docs/conf.py b/docs/conf.py
-index ff2d0d2..f8ff415 100644
 --- a/docs/conf.py
 +++ b/docs/conf.py
-@@ -27,6 +27,8 @@ docs_core.run_doxygen(doxygen_root="doxygen", doxygen_path="doxygen/xml")
+@@ -27,6 +27,8 @@
  docs_core.setup()
  
  external_projects_current_project = "rocfft"
 +external_projects_remote_repository = ""
 +external_projects_remote_branch = ""
- external_projects = []
  
  for sphinx_var in ROCmDocs.SPHINX_VARS:
+     globals()[sphinx_var] = getattr(docs_core, sphinx_var)
diff --git a/debian/patches/do-not-strictly-depend-on-sqlite3-v3.50.2.patch b/debian/patches/do-not-strictly-depend-on-sqlite3-v3.50.2.patch
new file mode 100644
index 0000000..fc6e543
--- /dev/null
+++ b/debian/patches/do-not-strictly-depend-on-sqlite3-v3.50.2.patch
@@ -0,0 +1,21 @@
+From: Talha Can Havadar <[e-mail]>
+Date: Wed, 26 Nov 2025 15:34:26 +0100
+Subject: do not strictly depend on sqlite3 v3.50.2
+
+---
+ cmake/sqlite.cmake | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/cmake/sqlite.cmake b/cmake/sqlite.cmake
+index 2dc2a28..a44e4ef 100644
+--- a/cmake/sqlite.cmake
++++ b/cmake/sqlite.cmake
+@@ -26,7 +26,7 @@ option( SQLITE_USE_SYSTEM_PACKAGE "Use SQLite3 from find_package" OFF )
+ 
+ if( SQLITE_USE_SYSTEM_PACKAGE )
+   # Require a safe baseline (fixes truncation/memory-corruption issues).
+-  find_package(SQLite3 3.50.2 REQUIRED)
++  find_package(SQLite3 REQUIRED)
+   list(APPEND static_depends PACKAGE SQLite3)
+   set(ROCFFT_SQLITE_LIB SQLite::SQLite3)
+ else()
diff --git a/debian/patches/fix-hiprtc-link.patch b/debian/patches/fix-hiprtc-link.patch
deleted file mode 100644
index 3ff2d1f..0000000
--- a/debian/patches/fix-hiprtc-link.patch
+++ /dev/null
@@ -1,29 +0,0 @@
-From: Cordell Bloor <[e-mail]>
-Date: Tue, 23 May 2023 18:57:14 -0600
-Subject: fix hiprtc link
-
-The upstream build code linking hiprtc doesn't work with the Debian
-package for hiprtc. The hip rtc library is correctly linked by
-hip::host, so there's no need to handle it separately. That said, some
-other packages for HIP (such as those provided by Spack), have patched
-out the automatic linking of hiprtc in hip::host, so upstream will
-probably want to find an alternative solution.
-
-Forwarded: not-needed
----
- library/src/CMakeLists.txt | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/library/src/CMakeLists.txt b/library/src/CMakeLists.txt
-index 63c584b..c02f2fb 100644
---- a/library/src/CMakeLists.txt
-+++ b/library/src/CMakeLists.txt
-@@ -56,7 +56,7 @@ else()
-   if( WIN32 )
-     set( ROCFFT_RTC_LINK_LIBS "${HIP_PATH}/lib/hiprtc.lib" )
-   else()
--    set( ROCFFT_RTC_LINK_LIBS -L${ROCM_PATH}/lib -lhiprtc -ldl )
-+    set( ROCFFT_RTC_LINK_LIBS hip::host -ldl )
-   endif()
- endif()
- 
diff --git a/debian/patches/series b/debian/patches/series
index 8c51f36..581e5fe 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,5 +1,5 @@
-fix-hiprtc-link.patch
 use-local-mathjax.patch
 Extend-docs-conf.py-for-offline-build.patch
 Add-version-script-to-control-exposed-symbols.patch
 Force-host-code-resultion.patch
+do-not-strictly-depend-on-sqlite3-v3.50.2.patch
diff --git a/debian/rules b/debian/rules
index d92552b..6cbc80a 100755
--- a/debian/rules
+++ b/debian/rules
@@ -2,6 +2,12 @@
 export CXX=hipcc
 export DEB_BUILD_MAINT_OPTIONS = hardening=+all optimize=-lto
 export DEB_CXXFLAGS_MAINT_PREPEND = -gz
+# -Wl,--gc-sections:
+# Fixes linker errors ("relocation refers to a discarded section") when using gtest.
+# The linker's section garbage collection incorrectly discards needed code due to
+# a toolchain mismatch (ROCm's clang vs. the system's GCC). This flag forces the
+# linker to correctly re-evaluate dependencies, keeping the required sections.
+export DEB_LDFLAGS_MAINT_PREPEND = -Wl,--gc-sections
 export VERBOSE=1
 
 # filter incompatible options from affecting device code
@@ -13,7 +19,6 @@ VERSION_STRING = $(shell sed -nr 's/^set.*VERSION_STRING \"([.0-9]+)\".*/\1/p' C
 
 CMAKE_FLAGS = \
 	-DCMAKE_BUILD_TYPE=Release \
-	-DCMAKE_SKIP_RPATH=ON \
 	-DGPU_TARGETS="$(shell rocm-target-arch --sep ';')" \
 	-DROCFFT_KERNEL_CACHE_ENABLE=OFF \
 	-DROCM_SYMLINK_LIBS=OFF \
diff --git a/debian/tests/control b/debian/tests/control
index bd8c7a5..6cc0da2 100644
--- a/debian/tests/control
+++ b/debian/tests/control
@@ -2,4 +2,4 @@ Test-Command: rocm-test-launcher /usr/libexec/rocm/librocfft0-tests/run-tests
 Features: test-name=librocfft0-tests
 Depends: librocfft0-tests, pkg-rocm-tools
 Restrictions: allow-stderr, skippable
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
diff --git a/docs/design/bluestein.rst b/designdocs/bluestein.rst
similarity index 100%
rename from docs/design/bluestein.rst
rename to designdocs/bluestein.rst
diff --git a/docs/design/buffer_assignment.rst b/designdocs/buffer_assignment.rst
similarity index 100%
rename from docs/design/buffer_assignment.rst
rename to designdocs/buffer_assignment.rst
diff --git a/docs/design/codegen.rst b/designdocs/codegen.rst
similarity index 99%
rename from docs/design/codegen.rst
rename to designdocs/codegen.rst
index 46b8255..28fdde0 100644
--- a/docs/design/codegen.rst
+++ b/designdocs/codegen.rst
@@ -308,7 +308,7 @@ tiling.  Different twiddle table strategies should extend the
 ``multiply`` methods.
 
 Twiddle tables may also require additional templates and arguments.
-See :ref:`Stockham tiling implementation`.
+See the Stockham tiling implementation section.
 
 Copyright and disclaimer
 ========================
diff --git a/docs/design/design.rst b/designdocs/design.rst
similarity index 66%
rename from docs/design/design.rst
rename to designdocs/design.rst
index 7cb5f7a..7e97b33 100644
--- a/docs/design/design.rst
+++ b/designdocs/design.rst
@@ -10,9 +10,9 @@ Design Documents
 
 The Design Documents contain proposals for features of the rocFFT library. They are intended as development proposals for engineering and contributors to the Open Source library. 
 
-The current proposals include the following:
+The current proposals in this directory include the following:
 
-  * :ref:`codegen`
-  * :ref:`runtime_compilation`
-  * :ref:`buffer_assignment`
-  * :ref:`bluestein`
+  * codegen
+  * runtime_compilation
+  * buffer_assignment
+  * bluestein
diff --git a/docs/design/images/bluestein_fig1.png b/designdocs/images/bluestein_fig1.png
similarity index 100%
rename from docs/design/images/bluestein_fig1.png
rename to designdocs/images/bluestein_fig1.png
Binary files a/docs/design/images/bluestein_fig1.png and b/designdocs/images/bluestein_fig1.png differ
diff --git a/docs/design/images/bluestein_fig2.png b/designdocs/images/bluestein_fig2.png
similarity index 100%
rename from docs/design/images/bluestein_fig2.png
rename to designdocs/images/bluestein_fig2.png
Binary files a/docs/design/images/bluestein_fig2.png and b/designdocs/images/bluestein_fig2.png differ
diff --git a/docs/design/images/bluestein_fig3.png b/designdocs/images/bluestein_fig3.png
similarity index 100%
rename from docs/design/images/bluestein_fig3.png
rename to designdocs/images/bluestein_fig3.png
Binary files a/docs/design/images/bluestein_fig3.png and b/designdocs/images/bluestein_fig3.png differ
diff --git a/docs/design/images/bluestein_fig4.png b/designdocs/images/bluestein_fig4.png
similarity index 100%
rename from docs/design/images/bluestein_fig4.png
rename to designdocs/images/bluestein_fig4.png
Binary files a/docs/design/images/bluestein_fig4.png and b/designdocs/images/bluestein_fig4.png differ
diff --git a/docs/design/runtime_compilation.rst b/designdocs/runtime_compilation.rst
similarity index 100%
rename from docs/design/runtime_compilation.rst
rename to designdocs/runtime_compilation.rst
diff --git a/docs/conf.py b/docs/conf.py
index c83a6fb..304d660 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -13,7 +13,7 @@ left_nav_title = f"rocFFT {version_number} Documentation"
 # for PDF output on Read the Docs
 project = "rocFFT Documentation"
 author = "Advanced Micro Devices, Inc."
-copyright = "Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved."
+copyright = "Copyright (c) 2025 Advanced Micro Devices, Inc. All rights reserved."
 version = version_number
 release = version_number
 
@@ -24,7 +24,6 @@ docs_core.run_doxygen(doxygen_root="doxygen", doxygen_path="doxygen/xml")
 docs_core.setup()
 
 external_projects_current_project = "rocfft"
-external_projects = []
 
 for sphinx_var in ROCmDocs.SPHINX_VARS:
     globals()[sphinx_var] = getattr(docs_core, sphinx_var)
diff --git a/docs/doxygen/Doxyfile b/docs/doxygen/Doxyfile
index c47b8fc..3fbe0d4 100644
--- a/docs/doxygen/Doxyfile
+++ b/docs/doxygen/Doxyfile
@@ -38,7 +38,7 @@ PROJECT_NAME           = "rocFFT"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = v1.0.32
+PROJECT_NUMBER         = v1.0.35
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
diff --git a/docs/how-to/enabling-logging.rst b/docs/how-to/enabling-logging.rst
new file mode 100644
index 0000000..9d9f59a
--- /dev/null
+++ b/docs/how-to/enabling-logging.rst
@@ -0,0 +1,134 @@
+.. meta::
+  :description: Enabling logging in rocFFT
+  :keywords: rocFFT, ROCm, API, documentation, logging
+
+
+.. _enabling-logging:
+
+********************************************************************
+Enabling logging in rocFFT
+********************************************************************
+
+rocFFT can write a variety of log messages to aid troubleshooting. Here are the different
+logs that rocFFT supports.
+
+*  **Trace logging**: Logs the library entry points (for example, ``rocfft_plan_create`` or ``rocfft_execute``) and their parameter
+   values when they are called. Error messages during plan creation and execution are also logged here.
+*  **Benchmark logging**: Logs the ``rocfft-bench`` command line when a plan is created.
+   You can use this command to rerun the same transform later.
+*  **Profile logging**: Logs a message for each kernel launched during plan execution.
+   This message contains the following elements:
+
+   *  Kernel duration
+   *  The size of the user data buffers seen by the kernel
+   *  Estimates for the observed memory bandwidth and bandwidth efficiency
+
+   .. note::
+   
+      To provide the kernel duration, rocFFT must use ``hipEvents`` and wait for each kernel to complete.
+      This might interfere with time measurement at higher levels, for example, for ``rocfft-bench``.
+
+*  **Plan logging**: Logs the plan details when a transform is executed, including the following:
+
+   *  Each TreeNode in the plan
+   *  The work buffer size required by the plan
+   *  The kernel grid and block dimensions
+   *  The kernel maximum occupancy (estimated by HIP)
+
+*  **Kernel I/O logging**: Logs the kernel details during plan execution, including the input to each
+   kernel (the data provided by the user) and the final output of the transform.
+
+   .. note::
+
+      The amount of data logged can become very large, particularly for 2D and 3D transforms, so
+      logging it to a file instead of stderr is usually a good idea. See the next section for more details.
+      
+      Writing the data involves extra ``hipMemcpy`` operations and serializing the
+      data to the log can also take a significant amount of time. Both of these factors affect performance.
+
+*  **Runtime compilation logging**: Logs details about runtime compilation during plan creation,
+   including the following:
+
+   *  The source code
+   *  Messages indicating a kernel was found in a cache, and did not need to be compiled at runtime
+   *  Compilation errors (if any)
+   *  Duration measurements indicating the time it took to generate source code for the kernel and compile the kernel
+
+   The source code for the kernels is delimited by lines containing the strings ``ROCFFT_RTC_BEGIN``
+   and ``ROCFFT_RTC_END``. This lets you isolate the source code for each kernel if a
+   single log contains code for multiple kernels.
+
+   .. note::
+
+      All non-code messages (except for compile errors) are written as C++ comments, so 
+      you can pass the whole file to clang-format to inspect the source code.
+
+      The source code details for the runtime compilation can be very large, so consider writing
+      this log to a file instead of stderr.
+
+*  **Tuning logging**: Logs details about any kernels that are tried and rejected while tuning is running.
+   It also logs messages when tuned solutions are used during plan building.
+*  **Graph logging**: Logs the graph of subplans during multi-GPU or multi-process plan execution.
+   Subplans include FFT plans, transpose plans (to reshape data for communication), and communication steps.
+   This is written as Graphviz data. The view of the global graph might be slightly different from
+   different nodes. This is because the current node has more visibility into subplans that run locally
+   than those that run on other nodes.
+
+Configuring the logging output
+==============================
+
+The logging output can be controlled using the ``ROCFFT_LAYER`` environment variable.
+``ROCFFT_LAYER`` is a numerical bitmask, where zero or more bits can be set to enable one or more logging layers.
+The log output is written to stderr by default.
+
+The following table maps the different logging layers to a ``ROCFFT_LAYER`` bit field value.
+To determine what value to set for ``ROCFFT_LAYER``, add up the values of all the layers you want to see.
+For example, to see the output for trace, profile, and plan logging, set ``ROCFFT_LAYER`` to ``13``
+(``1`` + ``4`` + ``8``).
+
+.. csv-table::
+   :header: "Log type","ROCFFT_LAYER bit field value"
+   :widths: 20, 20
+
+   "Trace logging","1"
+   "Benchmark logging","2"
+   "Profile logging","4"
+   "Plan logging","8"
+   "Kernel I/O logging","16"
+   "Runtime compilation logging","32"
+   "Tuning logging","64"
+   "Graph logging","128"
+
+Logging to a file
+=============================
+
+By default, messages are written to stderr, but they can be redirected to
+output files using the environment variables described in this section.
+Each type of log can be redirected separately using a unique environment variable.
+The corresponding log must be enabled using the ``ROCFFT_LAYER`` variable
+before any details can be logged to the file.
+For example, to redirect the trace log to a file, trace logging must
+also be enabled in the  ``ROCFFT_LAYER`` bit field.
+
+.. note::
+
+   Some log types, such as kernel I/O logging and runtime compilation logging, can generate
+   a large number of log entries, so redirecting their output to a file is recommended.
+
+The following table lists the environment variable to redirect logging for each
+log type. Set this variable to a valid file path to redirect the output of the corresponding log type.
+For example, to send the trace logging output to a file, enable the trace log, then set the
+``ROCFFT_LOG_TRACE_PATH`` variable to the name of the destination file.
+
+.. csv-table::
+   :header: "Log type","File redirection variable"
+   :widths: 20, 30
+
+   "Trace logging","``ROCFFT_LOG_TRACE_PATH``"
+   "Benchmark logging","``ROCFFT_LOG_BENCH_PATH``"
+   "Profile logging","``ROCFFT_LOG_PROFILE_PATH``"
+   "Plan logging","``ROCFFT_LOG_PLAN_PATH``"
+   "Kernel I/O logging","``ROCFFT_LOG_KERNELIO_PATH``"
+   "Runtime compilation logging","``ROCFFT_LOG_RTC_PATH``"
+   "Tuning logging","``ROCFFT_LOG_TUNING_PATH``"
+   "Graph logging","``ROCFFT_LOG_GRAPH_PATH``"
diff --git a/docs/how-to/load-store-callbacks.rst b/docs/how-to/load-store-callbacks.rst
index 9d37995..a8ee6ed 100644
--- a/docs/how-to/load-store-callbacks.rst
+++ b/docs/how-to/load-store-callbacks.rst
@@ -17,6 +17,11 @@ to the library using
 :cpp:func:`rocfft_execution_info_set_load_callback` and
 :cpp:func:`rocfft_execution_info_set_store_callback`.
 
+.. note::
+
+   Callback functions must be built as relocatable device code by
+   passing the ``-fgpu-rdc`` option to the compiler and linker.
+
 Device functions supplied as callbacks must load and store element
 data types appropriate for the transform being executed.
 
diff --git a/docs/how-to/working-with-rocfft.rst b/docs/how-to/working-with-rocfft.rst
index 26f8e57..7d764b8 100644
--- a/docs/how-to/working-with-rocfft.rst
+++ b/docs/how-to/working-with-rocfft.rst
@@ -181,7 +181,7 @@ You must allocate, initialize, and specify the input/output buffers that hold th
 For larger transforms, temporary work buffers might be needed. Because the library tries to minimize its own allocation of
 memory regions on the device, it expects you to manage the work buffers. The size of the buffer that is needed can be queried using
 :cpp:func:`rocfft_plan_get_work_buffer_size`. After allocation, it can be passed to the library using
-:cpp:func:`rocfft_execution_info_set_work_buffer`. The `GitHub repository <https://github.com/ROCm/rocFFT/tree/develop/clients/samples>`_
+:cpp:func:`rocfft_execution_info_set_work_buffer`. The `GitHub repository <https://github.com/ROCm/rocm-libraries/tree/develop/projects/rocfft/clients/samples>`_
 provide some samples and examples.
 
 Transform and array types 
@@ -316,8 +316,8 @@ reside on a different device and have its own layout parameters.
 
    The rocFFT APIs for declaring fields and bricks are currently experimental and
    subject to change in future releases. To submit feedback, questions, and comments
-   about these interfaces, use the `rocFFT issue tracker
-   <https://github.com/ROCmSoftwarePlatform/rocFFT/issues>`_.
+   about these interfaces, use the `rocm-libraries issue tracker
+   <https://github.com/ROCm/rocm-libraries/issues>`_.
 
 The workflow for using fields is as follows:
 
diff --git a/docs/index.rst b/docs/index.rst
index 71ef011..82f089d 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -15,7 +15,11 @@ The rocFFT library calculates discrete Fourier transforms for one, two, and thre
 supporting various data types for real and complex values.
 To learn more, see :doc:`What is rocFFT? <./what-is-rocfft>`
 
-The rocFFT public repository is located at `<https://github.com/ROCm/rocFFT>`_.
+The rocFFT public repository is located at `<https://github.com/ROCm/rocm-libraries/tree/develop/projects/rocfft>`_.
+
+.. note::
+
+   The rocFFT repository for ROCm 6.4.3 and earlier is located at `<https://github.com/ROCm/rocFFT>`_.
 
 .. grid:: 2
   :gutter: 3
@@ -38,10 +42,11 @@ The rocFFT public repository is located at `<https://github.com/ROCm/rocFFT>`_.
     * :doc:`Load and store callbacks <./how-to/load-store-callbacks>`
     * :doc:`Use runtime compilation <./how-to/runtime-compilation>`
     * :doc:`Distribute transforms <./how-to/distributed-transforms>`
+    * :doc:`Enable logging <./how-to/enabling-logging>`
 
   .. grid-item-card:: Samples
 
-    * `rocFFT GitHub client examples <https://github.com/ROCm/rocFFT/tree/develop/clients/samples>`_
+    * `rocFFT GitHub client examples <https://github.com/ROCm/rocm-libraries/tree/develop/projects/rocfft/clients/samples>`_
 
   .. grid-item-card:: API reference
 
diff --git a/docs/install/building-installing-rocfft.rst b/docs/install/building-installing-rocfft.rst
index 44fb458..5d5f2a1 100644
--- a/docs/install/building-installing-rocfft.rst
+++ b/docs/install/building-installing-rocfft.rst
@@ -32,7 +32,8 @@ You can use the GitHub releases tab to download the source code. This might prov
 than the prebuilt packages.
 
 rocFFT uses the AMD clang++ compiler and CMake. You can specify several options to customize your build.
-Use the following commands to build a shared library for the supported AMD GPUs:
+Use the following commands to build a shared library for the supported AMD GPUs.
+Run these commands from the ``rocm-libraries/projects/rocfft`` directory:
 
 .. code-block:: shell
 
@@ -78,7 +79,7 @@ rocFFT uses version 1.11 of GoogleTest.
 
 You can build the clients separately from the main library.
 For example, to build all the clients with an existing rocFFT library, invoke CMake from
-within the ``rocFFT-src/clients`` folder using these commands:
+within the ``rocm-libraries/projects/rocfft/rocFFT-src/clients`` folder using these commands:
 
 .. code-block:: shell
 
diff --git a/docs/license.md b/docs/license.md
index 7eeeef5..c1c707c 100644
--- a/docs/license.md
+++ b/docs/license.md
@@ -5,5 +5,7 @@ myst:
         "keywords": "rocFFT, FFT, ROCm, API, documentation, license"
 ---
 
+# License
+
 ```{include} ../LICENSE.md
 ```
diff --git a/docs/samples/README.md b/docs/samples/README.md
deleted file mode 100644
index ea0f091..0000000
--- a/docs/samples/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# Samples to demo using rocfft
-
-## `complex_1d`
-
-You may need to add the directories for amdclang++ and rocFFT to your
-`CMAKE_PREFIX_PATH`, and ensure that `amdclang++` is in your `PATH`.
-
-``` bash
-$ mkdir build && cd build
-$ cmake -DCMAKE_CXX_COMPILER=amdclang++ ..
-$ make
-```
diff --git a/docs/samples/complex_1d.cpp b/docs/samples/complex_1d.cpp
deleted file mode 100644
index e815f15..0000000
--- a/docs/samples/complex_1d.cpp
+++ /dev/null
@@ -1,178 +0,0 @@
-// Copyright (C) 2019 - 2022 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include <cassert>
-#include <complex>
-#include <iostream>
-#include <vector>
-
-#include <hip/hip_runtime_api.h>
-
-#include <rocfft/rocfft.h>
-
-int main(int argc, char* argv[])
-{
-    std::cout << "rocFFT complex 1d FFT example\n";
-
-    // The problem size
-    const size_t Nx      = (argc < 2) ? 8 : atoi(argv[1]);
-    const bool   inplace = (argc < 3) ? false : atoi(argv[2]);
-    std::cout << "Nx: " << Nx << "\tin-place: " << inplace << std::endl;
-
-    // Initialize data on the host:
-    std::cout << "Input:\n";
-    std::vector<std::complex<float>> cx(Nx);
-    for(size_t i = 0; i < Nx; i++)
-    {
-        cx[i] = std::complex<float>(i, 0);
-    }
-    for(size_t i = 0; i < Nx; i++)
-    {
-        std::cout << cx[i] << " ";
-    }
-    std::cout << std::endl;
-
-    // Create HIP device object and copy data:
-    float2* x = NULL;
-    hipMalloc(&x, cx.size() * sizeof(decltype(cx)::value_type));
-    float2* y = inplace ? (float2*)x : NULL;
-    if(!inplace)
-    {
-        hipMalloc(&y, cx.size() * sizeof(decltype(cx)::value_type));
-    }
-    hipMemcpy(x, cx.data(), cx.size() * sizeof(decltype(cx)::value_type), hipMemcpyHostToDevice);
-
-    rocfft_setup();
-
-    rocfft_status status = rocfft_status_success;
-
-    // Create forward plan
-    rocfft_plan forward = NULL;
-    status              = rocfft_plan_create(&forward,
-                                inplace ? rocfft_placement_inplace : rocfft_placement_notinplace,
-                                rocfft_transform_type_complex_forward,
-                                rocfft_precision_single,
-                                1, // Dimensions
-                                &Nx, // lengths
-                                1, // Number of transforms
-                                NULL); // Description
-    assert(status == rocfft_status_success);
-
-    // We may need work memory, which is passed via rocfft_execution_info
-    rocfft_execution_info forwardinfo = NULL;
-    status                            = rocfft_execution_info_create(&forwardinfo);
-    assert(status == rocfft_status_success);
-    size_t fbuffersize = 0;
-    status             = rocfft_plan_get_work_buffer_size(forward, &fbuffersize);
-    assert(status == rocfft_status_success);
-    void* fbuffer = NULL;
-    if(fbuffersize > 0)
-    {
-        hipMalloc(&fbuffer, fbuffersize);
-        status = rocfft_execution_info_set_work_buffer(forwardinfo, fbuffer, fbuffersize);
-        assert(status == rocfft_status_success);
-    }
-
-    // Create backward plan
-    rocfft_plan backward = NULL;
-    status               = rocfft_plan_create(&backward,
-                                inplace ? rocfft_placement_inplace : rocfft_placement_notinplace,
-                                rocfft_transform_type_complex_inverse,
-                                rocfft_precision_single,
-                                1, // Dimensions
-                                &Nx, // lengths
-                                1, // Number of transforms
-                                NULL); // Description
-    assert(status == rocfft_status_success);
-
-    // Execution info for the backward transform:
-    rocfft_execution_info backwardinfo = NULL;
-    status                             = rocfft_execution_info_create(&backwardinfo);
-    assert(status == rocfft_status_success);
-    size_t bbuffersize = 0;
-    status             = rocfft_plan_get_work_buffer_size(backward, &bbuffersize);
-    assert(status == rocfft_status_success);
-    void* bbuffer = NULL;
-    if(bbuffersize > 0)
-    {
-        hipMalloc(&bbuffer, bbuffersize);
-        status = rocfft_execution_info_set_work_buffer(backwardinfo, bbuffer, bbuffersize);
-        assert(status == rocfft_status_success);
-    }
-
-    // Execute the forward transform
-    status = rocfft_execute(forward,
-                            (void**)&x, // in_buffer
-                            (void**)&y, // out_buffer
-                            forwardinfo); // execution info
-    assert(status == rocfft_status_success);
-
-    // Copy result back to host
-    std::vector<std::complex<float>> cy(Nx);
-    hipMemcpy(cy.data(), y, cy.size() * sizeof(decltype(cy)::value_type), hipMemcpyDeviceToHost);
-
-    std::cout << "Transformed:\n";
-    for(size_t i = 0; i < cy.size(); i++)
-    {
-        std::cout << cy[i] << " ";
-    }
-    std::cout << std::endl;
-
-    // Execute the backward transform
-    rocfft_execute(backward,
-                   (void**)&y, // in_buffer
-                   (void**)&x, // out_buffer
-                   backwardinfo); // execution info
-
-    std::cout << "Transformed back:\n";
-    hipMemcpy(cy.data(), x, cy.size() * sizeof(decltype(cy)::value_type), hipMemcpyDeviceToHost);
-    for(size_t i = 0; i < cy.size(); i++)
-    {
-        std::cout << cy[i] << " ";
-    }
-    std::cout << std::endl;
-
-    const float overN = 1.0f / Nx;
-    float       error = 0.0f;
-    for(size_t i = 0; i < cx.size(); i++)
-    {
-        float diff = std::max(std::abs(cx[i].real() - cy[i].real() * overN),
-                              std::abs(cx[i].imag() - cy[i].imag() * overN));
-        if(diff > error)
-        {
-            error = diff;
-        }
-    }
-    std::cout << "Maximum error: " << error << "\n";
-
-    hipFree(x);
-    if(!inplace)
-    {
-        hipFree(y);
-    }
-    hipFree(fbuffer);
-    hipFree(bbuffer);
-
-    // Destroy plans
-    rocfft_plan_destroy(forward);
-    rocfft_plan_destroy(backward);
-
-    rocfft_cleanup();
-}
diff --git a/docs/samples/complex_2d.cpp b/docs/samples/complex_2d.cpp
deleted file mode 100644
index 9da818b..0000000
--- a/docs/samples/complex_2d.cpp
+++ /dev/null
@@ -1,198 +0,0 @@
-// Copyright (C) 2019 - 2022 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include <cassert>
-#include <complex>
-#include <iostream>
-#include <vector>
-
-#include <hip/hip_runtime_api.h>
-
-#include <rocfft/rocfft.h>
-
-int main(int argc, char* argv[])
-{
-    std::cout << "rocFFT complex 2d FFT example\n";
-
-    // The problem size
-    const size_t Nx      = (argc < 2) ? 8 : atoi(argv[1]);
-    const size_t Ny      = (argc < 3) ? 8 : atoi(argv[2]);
-    const bool   inplace = (argc < 4) ? false : atoi(argv[3]);
-    std::cout << "Nx: " << Nx << "\tNy: " << Ny << "\tin-place: " << inplace << std::endl;
-
-    // Initialize data on the host
-    std::cout << "Input:\n";
-    std::vector<std::complex<float>> cx(Nx * Ny);
-    for(size_t i = 0; i < Nx; i++)
-    {
-        for(size_t j = 0; j < Ny; j++)
-        {
-            cx[i * Ny + j] = std::complex<float>(i + j, 0.0);
-        }
-    }
-    for(size_t i = 0; i < Nx; i++)
-    {
-        for(size_t j = 0; j < Ny; j++)
-        {
-            std::cout << cx[i * Ny + j] << " ";
-        }
-        std::cout << "\n";
-    }
-    std::cout << "\n";
-
-    rocfft_setup();
-
-    // Create HIP device object and copy data:
-    float2* x = NULL;
-    hipMalloc(&x, cx.size() * sizeof(decltype(cx)::value_type));
-    float2* y = inplace ? (float2*)x : NULL;
-    if(!inplace)
-    {
-        hipMalloc(&y, cx.size() * sizeof(decltype(cx)::value_type));
-    }
-    hipMemcpy(x, cx.data(), cx.size() * sizeof(decltype(cx)::value_type), hipMemcpyHostToDevice);
-
-    // Length are in reverse order because rocfft is column-major.
-    const size_t lengths[2] = {Ny, Nx};
-
-    rocfft_status status = rocfft_status_success;
-
-    // Create plans
-    rocfft_plan forward = NULL;
-    status              = rocfft_plan_create(&forward,
-                                inplace ? rocfft_placement_inplace : rocfft_placement_notinplace,
-                                rocfft_transform_type_complex_forward,
-                                rocfft_precision_single,
-                                2, // Dimensions
-                                lengths, // lengths
-                                1, // Number of transforms
-                                NULL); // Description
-    assert(status == rocfft_status_success);
-
-    // We may need work memory, which is passed via rocfft_execution_info
-    rocfft_execution_info forwardinfo = NULL;
-    status                            = rocfft_execution_info_create(&forwardinfo);
-    assert(status == rocfft_status_success);
-    size_t fbuffersize = 0;
-    status             = rocfft_plan_get_work_buffer_size(forward, &fbuffersize);
-    assert(status == rocfft_status_success);
-    void* fbuffer = NULL;
-    if(fbuffersize > 0)
-    {
-        hipMalloc(&fbuffer, fbuffersize);
-        status = rocfft_execution_info_set_work_buffer(forwardinfo, fbuffer, fbuffersize);
-        assert(status == rocfft_status_success);
-    }
-
-    // Create plans
-    rocfft_plan backward = NULL;
-    status               = rocfft_plan_create(&backward,
-                                inplace ? rocfft_placement_inplace : rocfft_placement_notinplace,
-                                rocfft_transform_type_complex_inverse,
-                                rocfft_precision_single,
-                                2, // Dimensions
-                                lengths, // lengths
-                                1, // Number of transforms
-                                NULL); // Description
-    assert(status == rocfft_status_success);
-
-    // Execution info for the backward transform:
-    rocfft_execution_info backwardinfo = NULL;
-    status                             = rocfft_execution_info_create(&backwardinfo);
-    assert(status == rocfft_status_success);
-    size_t bbuffersize = 0;
-    status             = rocfft_plan_get_work_buffer_size(backward, &bbuffersize);
-    assert(status == rocfft_status_success);
-    void* bbuffer = NULL;
-    if(bbuffersize > 0)
-    {
-        hipMalloc(&bbuffer, bbuffersize);
-        status = rocfft_execution_info_set_work_buffer(backwardinfo, bbuffer, bbuffersize);
-        assert(status == rocfft_status_success);
-    }
-
-    // Execute the forward transform
-    status = rocfft_execute(forward,
-                            (void**)&x, // in_buffer
-                            (void**)&y, // out_buffer
-                            forwardinfo); // execution info
-    assert(status == rocfft_status_success);
-
-    // Copy result back to host
-    std::vector<std::complex<float>> cy(cx.size());
-    hipMemcpy(cy.data(), y, cy.size() * sizeof(decltype(cy)::value_type), hipMemcpyDeviceToHost);
-
-    std::cout << "Transformed:\n";
-    for(size_t i = 0; i < Nx; i++)
-    {
-        for(size_t j = 0; j < Ny; j++)
-        {
-            std::cout << cy[i * Ny + j] << " ";
-        }
-        std::cout << "\n";
-    }
-    std::cout << "\n";
-
-    // Execute the backward transform
-    status = rocfft_execute(backward,
-                            (void**)&y, // in_buffer
-                            (void**)&x, // out_buffer
-                            backwardinfo); // execution info
-    assert(status == rocfft_status_success);
-
-    hipMemcpy(cy.data(), x, cy.size() * sizeof(decltype(cy)::value_type), hipMemcpyDeviceToHost);
-    std::cout << "Transformed back:\n";
-    for(size_t i = 0; i < Nx; i++)
-    {
-        for(size_t j = 0; j < Ny; j++)
-        {
-            std::cout << cy[i * Ny + j] << " ";
-        }
-        std::cout << "\n";
-    }
-    std::cout << "\n";
-
-    const float overN = 1.0f / cx.size();
-    float       error = 0.0f;
-    for(size_t i = 0; i < cx.size(); i++)
-    {
-        float diff = std::max(std::abs(cx[i].real() - cy[i].real() * overN),
-                              std::abs(cx[i].imag() - cy[i].imag() * overN));
-        if(diff > error)
-        {
-            error = diff;
-        }
-    }
-    std::cout << "Maximum error: " << error << "\n";
-
-    hipFree(x);
-    if(!inplace)
-    {
-        hipFree(y);
-    }
-    hipFree(fbuffer);
-    hipFree(bbuffer);
-
-    // Destroy plans
-    rocfft_plan_destroy(forward);
-    rocfft_plan_destroy(backward);
-
-    rocfft_cleanup();
-}
diff --git a/docs/samples/complex_3d.cpp b/docs/samples/complex_3d.cpp
deleted file mode 100644
index b547d7e..0000000
--- a/docs/samples/complex_3d.cpp
+++ /dev/null
@@ -1,218 +0,0 @@
-// Copyright (C) 2019 - 2022 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights