From 4c4c1135394af149b75ffca72410232df6d1812e Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 24 Jan 2024 09:19:09 +0000
Subject: [PATCH 001/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 67a36a9104..ef3ce4bc8d 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 67a36a9104097cd6a8ae6efee1018e249f2fe441
+Subproject commit ef3ce4bc8db008f58249241c16c80f7e6e600fa9

From c019201cc1f54366ee254c0126d8bbd01fd10b13 Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 24 Jan 2024 21:25:26 +0000
Subject: [PATCH 002/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 67a36a9104..ef3ce4bc8d 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 67a36a9104097cd6a8ae6efee1018e249f2fe441
+Subproject commit ef3ce4bc8db008f58249241c16c80f7e6e600fa9

From de7bd34d48fd92ac688be603ff24bfbe084a3b4d Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 24 Jan 2024 21:33:37 +0000
Subject: [PATCH 003/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index f800f5a2fa..ef3ce4bc8d 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit f800f5a2fa9a961699345e6febe740b4b8f4760e
+Subproject commit ef3ce4bc8db008f58249241c16c80f7e6e600fa9

From 99b8a73cd8f4833d1668beee6fa811e9c5b6e416 Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 24 Jan 2024 23:41:48 +0000
Subject: [PATCH 004/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index f800f5a2fa..ef3ce4bc8d 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit f800f5a2fa9a961699345e6febe740b4b8f4760e
+Subproject commit ef3ce4bc8db008f58249241c16c80f7e6e600fa9

From 4a388a139f6e09386fab9fcc7506f6db88209ffa Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 25 Jan 2024 03:28:26 +0000
Subject: [PATCH 005/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 5b1eef31ed..ef3ce4bc8d 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 5b1eef31ed4c5935285ef780dc74d35cea086b49
+Subproject commit ef3ce4bc8db008f58249241c16c80f7e6e600fa9

From 7f1c2862600ef0ff9902b20ca54aca327e926cb8 Mon Sep 17 00:00:00 2001
From: Tim Liu <timl@nvidia.com>
Date: Thu, 25 Jan 2024 13:59:33 +0800
Subject: [PATCH 006/132] Init version 24.04.0-SNAPSHOT (#1723)

* Init version 24.04.0-SNAPSHOT

Signed-off-by: Tim Liu <timl@nvidia.com>

* Copyright 2024

Signed-off-by: Tim Liu <timl@nvidia.com>

---------

Signed-off-by: Tim Liu <timl@nvidia.com>
---
 .gitmodules                 | 2 +-
 CONTRIBUTING.md             | 2 +-
 pom.xml                     | 4 ++--
 src/main/cpp/CMakeLists.txt | 4 ++--
 thirdparty/cudf             | 2 +-
 5 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.gitmodules b/.gitmodules
index 6b6f69d695..103a678946 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,4 +1,4 @@
 [submodule "thirdparty/cudf"]
 	path = thirdparty/cudf
 	url = https://github.com/rapidsai/cudf.git
-	branch = branch-24.02
+	branch = branch-24.04
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5fb76d548e..60dd78e5d8 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -160,7 +160,7 @@ $ ./build/build-in-docker install ...
 ```
 
 Now cd to ~/repos/NVIDIA/spark-rapids and build with one of the options from
-[spark-rapids instructions](https://github.com/NVIDIA/spark-rapids/blob/branch-24.02/CONTRIBUTING.md#building-from-source).
+[spark-rapids instructions](https://github.com/NVIDIA/spark-rapids/blob/branch-24.04/CONTRIBUTING.md#building-from-source).
 
 ```bash
 $ ./build/buildall
diff --git a/pom.xml b/pom.xml
index 4f2d19e45c..14bfa4bd4a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-  Copyright (c) 2022-2023, NVIDIA CORPORATION.
+  Copyright (c) 2022-2024, NVIDIA CORPORATION.
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -21,7 +21,7 @@
 
   <groupId>com.nvidia</groupId>
   <artifactId>spark-rapids-jni</artifactId>
-  <version>24.02.0-SNAPSHOT</version>
+  <version>24.04.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>RAPIDS Accelerator JNI for Apache Spark</name>
   <description>
diff --git a/src/main/cpp/CMakeLists.txt b/src/main/cpp/CMakeLists.txt
index 1ad65687e2..3ac9703bf7 100644
--- a/src/main/cpp/CMakeLists.txt
+++ b/src/main/cpp/CMakeLists.txt
@@ -1,5 +1,5 @@
 # =============================================================================
-# Copyright (c) 2022-2023, NVIDIA CORPORATION.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 # in compliance with the License. You may obtain a copy of the License at
@@ -32,7 +32,7 @@ rapids_cuda_init_architectures(SPARK_RAPIDS_JNI)
 
 project(
   SPARK_RAPIDS_JNI
-  VERSION 24.02.00
+  VERSION 24.04.00
   LANGUAGES C CXX CUDA
 )
 
diff --git a/thirdparty/cudf b/thirdparty/cudf
index ef3ce4bc8d..0a4ce51366 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit ef3ce4bc8db008f58249241c16c80f7e6e600fa9
+Subproject commit 0a4ce5136685761d3a9d0541f3e2e8ec8867e3cf

From e1c0527319b307ca5705d1af229f5362fb3f97db Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 25 Jan 2024 22:06:53 +0000
Subject: [PATCH 007/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 0cd58fbec6..0a4ce51366 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 0cd58fbec63d5e461b487e7e37aa9942ebe0f116
+Subproject commit 0a4ce5136685761d3a9d0541f3e2e8ec8867e3cf

From f4f0313846bf2d4627b08440f2ce4cc525935990 Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 26 Jan 2024 03:03:00 +0000
Subject: [PATCH 008/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 821f4dea10..0a4ce51366 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 821f4dea107db6a51fcbffff997fa6844ab5565f
+Subproject commit 0a4ce5136685761d3a9d0541f3e2e8ec8867e3cf

From e96686748b240d0806fddc5fb3829c8385006f0b Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 26 Jan 2024 12:57:40 +0000
Subject: [PATCH 009/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 821f4dea10..0a4ce51366 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 821f4dea107db6a51fcbffff997fa6844ab5565f
+Subproject commit 0a4ce5136685761d3a9d0541f3e2e8ec8867e3cf

From 3ac189ce1526b4fdb00cf8c7a57522e5eb59c4e1 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 26 Jan 2024 22:06:41 +0800
Subject: [PATCH 010/132] Update submodule cudf to
 a41238fd009403030b6f172025263633c913f82c (#1742)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 0a4ce51366..a41238fd00 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 0a4ce5136685761d3a9d0541f3e2e8ec8867e3cf
+Subproject commit a41238fd009403030b6f172025263633c913f82c

From 8adcbeb2c591728f5732a549f4977b10877ecf41 Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Mon, 29 Jan 2024 07:13:57 +0000
Subject: [PATCH 011/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 821f4dea10..a41238fd00 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 821f4dea107db6a51fcbffff997fa6844ab5565f
+Subproject commit a41238fd009403030b6f172025263633c913f82c

From a39c0f25e634680d6c6c9fa9eeaf8a7f9011e70b Mon Sep 17 00:00:00 2001
From: Jason Lowe <jlowe@nvidia.com>
Date: Mon, 29 Jan 2024 12:40:12 -0600
Subject: [PATCH 012/132] Update spark_resource_adaptor to RMM removing
 mem_info APIs (#1748)

Signed-off-by: Jason Lowe <jlowe@nvidia.com>
---
 src/main/cpp/src/SparkResourceAdaptorJni.cpp | 9 +--------
 thirdparty/cudf                              | 2 +-
 2 files changed, 2 insertions(+), 9 deletions(-)

diff --git a/src/main/cpp/src/SparkResourceAdaptorJni.cpp b/src/main/cpp/src/SparkResourceAdaptorJni.cpp
index b8fb337bf2..2df1c7ea77 100644
--- a/src/main/cpp/src/SparkResourceAdaptorJni.cpp
+++ b/src/main/cpp/src/SparkResourceAdaptorJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -401,8 +401,6 @@ class spark_resource_adaptor final : public rmm::mr::device_memory_resource {
 
   rmm::mr::device_memory_resource* get_wrapped_resource() { return resource; }
 
-  bool supports_get_mem_info() const noexcept override { return resource->supports_get_mem_info(); }
-
   bool supports_streams() const noexcept override { return resource->supports_streams(); }
 
   /**
@@ -1800,11 +1798,6 @@ class spark_resource_adaptor final : public rmm::mr::device_memory_resource {
       dealloc_core(false, lock);
     }
   }
-
-  std::pair<size_t, size_t> do_get_mem_info(rmm::cuda_stream_view stream) const override
-  {
-    return resource->get_mem_info(stream);
-  }
 };
 
 }  // namespace
diff --git a/thirdparty/cudf b/thirdparty/cudf
index a41238fd00..d5db68e018 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit a41238fd009403030b6f172025263633c913f82c
+Subproject commit d5db68e018d720094489325d5547a7ed82f22b0d

From 59214e451ee30cac446c80c3ad56af59114b976b Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Mon, 29 Jan 2024 19:37:39 +0000
Subject: [PATCH 013/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 821f4dea10..d5db68e018 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 821f4dea107db6a51fcbffff997fa6844ab5565f
+Subproject commit d5db68e018d720094489325d5547a7ed82f22b0d

From 6b7f237fefff8a1601d9ba3b9f6c6dab600075c7 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 30 Jan 2024 05:27:11 +0800
Subject: [PATCH 014/132] Update submodule cudf to
 1422a4b7f94f66275b3a641ecaf3533815111f8e (#1750)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index d5db68e018..1422a4b7f9 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit d5db68e018d720094489325d5547a7ed82f22b0d
+Subproject commit 1422a4b7f94f66275b3a641ecaf3533815111f8e

From 109a843ce737b57b96d6171daf83c396c7111868 Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Mon, 29 Jan 2024 23:02:43 +0000
Subject: [PATCH 015/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index fc2b9771f1..1422a4b7f9 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit fc2b9771f17644243817a339e218360aa97a1a79
+Subproject commit 1422a4b7f94f66275b3a641ecaf3533815111f8e

From 0445d85429115be1137a90e2bc00dc90d1546f2e Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 30 Jan 2024 11:30:47 +0800
Subject: [PATCH 016/132] Update submodule cudf to
 57bbe94e995b9a0365276e4cb26853dce219e22a (#1753)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 1422a4b7f9..57bbe94e99 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 1422a4b7f94f66275b3a641ecaf3533815111f8e
+Subproject commit 57bbe94e995b9a0365276e4cb26853dce219e22a

From cfefc6ceddc34e5affa61ed63d75a7436b6ffaee Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 31 Jan 2024 12:09:51 +0800
Subject: [PATCH 017/132] Update submodule cudf to
 6ed75ffddcd678a5dbcfd5f0e2dccf98531b4282 (#1754)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 57bbe94e99..6ed75ffddc 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 57bbe94e995b9a0365276e4cb26853dce219e22a
+Subproject commit 6ed75ffddcd678a5dbcfd5f0e2dccf98531b4282

From f3b8f8d64e2a7ab157f3127d301a4a6b3830739f Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 1 Feb 2024 11:28:59 +0800
Subject: [PATCH 018/132] Update submodule cudf to
 bb59715162218c0c638f5c368e6871ca15168838 (#1755)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 6ed75ffddc..bb59715162 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 6ed75ffddcd678a5dbcfd5f0e2dccf98531b4282
+Subproject commit bb59715162218c0c638f5c368e6871ca15168838

From 2ec85529f965d6b149e973d933309991aa35f807 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 1 Feb 2024 18:06:26 +0800
Subject: [PATCH 019/132] Update submodule cudf to
 767dde16e413f34cac16cb0b96b7eca18d71b7e9 (#1756)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index bb59715162..767dde16e4 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit bb59715162218c0c638f5c368e6871ca15168838
+Subproject commit 767dde16e413f34cac16cb0b96b7eca18d71b7e9

From 729830828890fb8bc9ed7d03224b46c8caca67a4 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 2 Feb 2024 05:33:02 +0800
Subject: [PATCH 020/132] Update submodule cudf to
 2b0d9876ed02c1e4ea50907ac0d917669d51348c (#1757)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 767dde16e4..2b0d9876ed 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 767dde16e413f34cac16cb0b96b7eca18d71b7e9
+Subproject commit 2b0d9876ed02c1e4ea50907ac0d917669d51348c

From 3e374b0a074edbc2666c51b41db97e7e5fc61cc4 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 2 Feb 2024 12:07:05 +0800
Subject: [PATCH 021/132] Update submodule cudf to
 b80f4e2e8ef15bbaad7dfde1ac6c8adc93cfd46d (#1758)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 2b0d9876ed..b80f4e2e8e 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 2b0d9876ed02c1e4ea50907ac0d917669d51348c
+Subproject commit b80f4e2e8ef15bbaad7dfde1ac6c8adc93cfd46d

From 32c9a8e3a35582597e0ab57eb7c0e941529dc43a Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Sat, 3 Feb 2024 11:31:57 +0800
Subject: [PATCH 022/132] Update submodule cudf to
 6cebf2294ff3cb5ed4d4712ccbb26f6a27687ad5 (#1760)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index b80f4e2e8e..6cebf2294f 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit b80f4e2e8ef15bbaad7dfde1ac6c8adc93cfd46d
+Subproject commit 6cebf2294ff3cb5ed4d4712ccbb26f6a27687ad5

From d78993212c1b93a988a3c8ede0c5fb1afe96482c Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Mon, 5 Feb 2024 21:31:46 +0800
Subject: [PATCH 023/132] Update submodule cudf to
 690f7df991e2b04096404f0ef0747af97f55284c (#1761)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 6cebf2294f..690f7df991 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 6cebf2294ff3cb5ed4d4712ccbb26f6a27687ad5
+Subproject commit 690f7df991e2b04096404f0ef0747af97f55284c

From 025dad19a4556c30a445d48c77df8289ab2bcbd9 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 6 Feb 2024 05:33:15 +0800
Subject: [PATCH 024/132] Update submodule cudf to
 dfc7f257cce9a7d094cec12b829992e52e8c40d0 (#1762)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 690f7df991..dfc7f257cc 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 690f7df991e2b04096404f0ef0747af97f55284c
+Subproject commit dfc7f257cce9a7d094cec12b829992e52e8c40d0

From 79d15c140f32388823280efacbe4775c514dc6f4 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 6 Feb 2024 12:06:17 +0800
Subject: [PATCH 025/132] Update submodule cudf to
 6b989f4ade91b218b460429fc4ce7ed66c39ad13 (#1763)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index dfc7f257cc..6b989f4ade 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit dfc7f257cce9a7d094cec12b829992e52e8c40d0
+Subproject commit 6b989f4ade91b218b460429fc4ce7ed66c39ad13

From 5c792395ab7b2d8c04b5085689305c3af7e89cc9 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 6 Feb 2024 23:26:13 +0800
Subject: [PATCH 026/132] Update submodule cudf to
 20ed009003944be776e28c26301354be287726f9 (#1764)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 6b989f4ade..20ed009003 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 6b989f4ade91b218b460429fc4ce7ed66c39ad13
+Subproject commit 20ed009003944be776e28c26301354be287726f9

From 31f1585cb40e8c5504f0a7015b890501476b01b3 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 7 Feb 2024 05:27:35 +0800
Subject: [PATCH 027/132] Update submodule cudf to
 72ecbe96788f6dc76d6f9f45dd7607dd38c90978 (#1765)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 20ed009003..72ecbe9678 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 20ed009003944be776e28c26301354be287726f9
+Subproject commit 72ecbe96788f6dc76d6f9f45dd7607dd38c90978

From c97c1941080272e638abca3f2690092809dc3932 Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 7 Feb 2024 03:03:38 +0000
Subject: [PATCH 028/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index c78033b7e7..72ecbe9678 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit c78033b7e77bebf9596d971b41714e1c4f29bb8f
+Subproject commit 72ecbe96788f6dc76d6f9f45dd7607dd38c90978

From b4e0fe094ccfbe28d57edfddefded5fc124d4a0f Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 7 Feb 2024 11:29:29 +0800
Subject: [PATCH 029/132] Update submodule cudf to
 072d9d4a0ba3cec6e869badcc484ef911a000303 (#1768)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 72ecbe9678..072d9d4a0b 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 72ecbe96788f6dc76d6f9f45dd7607dd38c90978
+Subproject commit 072d9d4a0ba3cec6e869badcc484ef911a000303

From 8bfe9d588828046dd1c410733fa4db6731199d3e Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 8 Feb 2024 05:32:27 +0800
Subject: [PATCH 030/132] Update submodule cudf to
 63a1c9ea8f87556de28f86c9b25f1b2b63a64e2c (#1769)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 072d9d4a0b..63a1c9ea8f 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 072d9d4a0ba3cec6e869badcc484ef911a000303
+Subproject commit 63a1c9ea8f87556de28f86c9b25f1b2b63a64e2c

From 5f4fa8288fa897a6fcd477b42f467f89a3c83e65 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 8 Feb 2024 12:09:05 +0800
Subject: [PATCH 031/132] Update submodule cudf to
 285b8362f391cb8babf57d0dd7b42cf90858862c (#1770)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 63a1c9ea8f..285b8362f3 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 63a1c9ea8f87556de28f86c9b25f1b2b63a64e2c
+Subproject commit 285b8362f391cb8babf57d0dd7b42cf90858862c

From 31235d4856096898607677e7bcb747af435565b6 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 8 Feb 2024 17:27:23 +0800
Subject: [PATCH 032/132] Update submodule cudf to
 73bac8329c659fdaf0c54ae250dca4b46f55ad8a (#1771)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 285b8362f3..73bac8329c 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 285b8362f391cb8babf57d0dd7b42cf90858862c
+Subproject commit 73bac8329c659fdaf0c54ae250dca4b46f55ad8a

From b7eeb99e1f0b86bb1c944ba1bbeee9990df70112 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 8 Feb 2024 23:32:45 +0800
Subject: [PATCH 033/132] Update submodule cudf to
 47d28a0850168ddc54180d075dd51199bce85674 (#1772)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 73bac8329c..47d28a0850 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 73bac8329c659fdaf0c54ae250dca4b46f55ad8a
+Subproject commit 47d28a0850168ddc54180d075dd51199bce85674

From be58f7d70b7f77f15f5c782c4013e7a83fb4361c Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 9 Feb 2024 05:27:26 +0800
Subject: [PATCH 034/132] Update submodule cudf to
 c3cf7c6587e069d032ac79c605c0c3d2a80673af (#1773)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 47d28a0850..c3cf7c6587 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 47d28a0850168ddc54180d075dd51199bce85674
+Subproject commit c3cf7c6587e069d032ac79c605c0c3d2a80673af

From 7c1eeb46d24995338281bf2ff313a30ad4239743 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 9 Feb 2024 12:09:23 +0800
Subject: [PATCH 035/132] Update submodule cudf to
 fbb1f899d6fdf44272c822037b2c8e9b62256668 (#1774)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index c3cf7c6587..fbb1f899d6 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit c3cf7c6587e069d032ac79c605c0c3d2a80673af
+Subproject commit fbb1f899d6fdf44272c822037b2c8e9b62256668

From c33b59101bc21d371af0e1e8fc762a38b2dc03e2 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 9 Feb 2024 23:26:14 +0800
Subject: [PATCH 036/132] Update submodule cudf to
 6638b5248fdf8cfcdff29f8209799f02abf77de1 (#1775)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index fbb1f899d6..6638b5248f 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit fbb1f899d6fdf44272c822037b2c8e9b62256668
+Subproject commit 6638b5248fdf8cfcdff29f8209799f02abf77de1

From 2f8653aacf233e7252d112a048b681108d5f3f5b Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Sat, 10 Feb 2024 06:06:29 +0800
Subject: [PATCH 037/132] Update submodule cudf to
 e36718b146bac35069e388e4b4748291c4ff6049 (#1776)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 6638b5248f..e36718b146 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 6638b5248fdf8cfcdff29f8209799f02abf77de1
+Subproject commit e36718b146bac35069e388e4b4748291c4ff6049

From 23ca28a9d44930ecb00cd837023d8ada55f3798a Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Sat, 10 Feb 2024 17:25:47 +0800
Subject: [PATCH 038/132] [submodule-sync] bot-submodule-sync-branch-24.04 to
 branch-24.04 [skip ci] [bot] (#1777)

* Update submodule cudf to 8edbeca2242985176f0f23dfd9a2dbd54b4360ae

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

* Update submodule cudf to 630c885001b679cb16ee997c0249b9c69212f4d1

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

---------

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index e36718b146..630c885001 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit e36718b146bac35069e388e4b4748291c4ff6049
+Subproject commit 630c885001b679cb16ee997c0249b9c69212f4d1

From 0ebb1fb6d9149789f5296861c22fff7b7104dae8 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 13 Feb 2024 05:27:03 +0800
Subject: [PATCH 039/132] Update submodule cudf to
 49c2995b1b861b12d3b25ad997adec9c50ed872f (#1779)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 630c885001..49c2995b1b 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 630c885001b679cb16ee997c0249b9c69212f4d1
+Subproject commit 49c2995b1b861b12d3b25ad997adec9c50ed872f

From 52c994256635ecb3e5092951ea5e41a7f200acbc Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Mon, 12 Feb 2024 22:57:22 +0000
Subject: [PATCH 040/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 82f6a5356a..49c2995b1b 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 82f6a5356aa10fd22c13f6aa85d1770c4c1a1c1b
+Subproject commit 49c2995b1b861b12d3b25ad997adec9c50ed872f

From 89fcc0ebf5cdc1036f5bfa08414fced8672529c3 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 13 Feb 2024 12:10:55 +0800
Subject: [PATCH 041/132] Update submodule cudf to
 d84870723569dfa3662cf2c79a6a4dd3dc33899f (#1782)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 49c2995b1b..d848707235 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 49c2995b1b861b12d3b25ad997adec9c50ed872f
+Subproject commit d84870723569dfa3662cf2c79a6a4dd3dc33899f

From 6ad8310fe0af8f9a264295a87c609861c623549e Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 14 Feb 2024 05:34:33 +0800
Subject: [PATCH 042/132] Update submodule cudf to
 d6902b083f1b74d508b92ba90e099e55f8ec0954 (#1784)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index d848707235..d6902b083f 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit d84870723569dfa3662cf2c79a6a4dd3dc33899f
+Subproject commit d6902b083f1b74d508b92ba90e099e55f8ec0954

From b7acd403281e81c360a0474fc32b5624441a9626 Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 14 Feb 2024 01:37:47 +0000
Subject: [PATCH 043/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 33ffdf5b71..d6902b083f 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 33ffdf5b71f639d83c6e31d76129a5ce74bf23cd
+Subproject commit d6902b083f1b74d508b92ba90e099e55f8ec0954

From 968b149c53c0d25c7106071227905bc9126dcea2 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 14 Feb 2024 11:27:13 +0800
Subject: [PATCH 044/132] Update submodule cudf to
 ac4debdf47d64c1cec9e689e18c738b5b6714e71 (#1786)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index d6902b083f..ac4debdf47 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit d6902b083f1b74d508b92ba90e099e55f8ec0954
+Subproject commit ac4debdf47d64c1cec9e689e18c738b5b6714e71

From f8f750b567169e323a38425fd232a37033b51047 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 15 Feb 2024 05:34:03 +0800
Subject: [PATCH 045/132] Update submodule cudf to
 ee1c76897ebe9a1c9796619de2c80a1fac7bc268 (#1787)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index ac4debdf47..ee1c76897e 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit ac4debdf47d64c1cec9e689e18c738b5b6714e71
+Subproject commit ee1c76897ebe9a1c9796619de2c80a1fac7bc268

From 42ecf701fad3e02c2e8c32d74484a0211e0a0d9b Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 15 Feb 2024 11:28:36 +0800
Subject: [PATCH 046/132] Update submodule cudf to
 e57afddcb52c9c91c37b88733efc5a0880904454 (#1788)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index ee1c76897e..e57afddcb5 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit ee1c76897ebe9a1c9796619de2c80a1fac7bc268
+Subproject commit e57afddcb52c9c91c37b88733efc5a0880904454

From 22971240c2bcd659311e6abc85db330103505a35 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 15 Feb 2024 21:26:33 +0800
Subject: [PATCH 047/132] Update submodule cudf to
 99ed8b9977cf52a5188637959bce9ca5b1f00ab9 (#1789)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index e57afddcb5..99ed8b9977 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit e57afddcb52c9c91c37b88733efc5a0880904454
+Subproject commit 99ed8b9977cf52a5188637959bce9ca5b1f00ab9

From 638d7f740eb6af9453b444c4b092b5b86c4453cc Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 16 Feb 2024 05:36:36 +0800
Subject: [PATCH 048/132] Update submodule cudf to
 3ba63c3c3cb72950adc4c9699fcfa1a72796a041 (#1790)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 99ed8b9977..3ba63c3c3c 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 99ed8b9977cf52a5188637959bce9ca5b1f00ab9
+Subproject commit 3ba63c3c3cb72950adc4c9699fcfa1a72796a041

From bafb540def8f892046298907a765e0945b3e49bb Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 16 Feb 2024 12:08:58 +0800
Subject: [PATCH 049/132] Update submodule cudf to
 aa9d4846e80fad133e7af19aba99cefa04cb8b7b (#1791)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 3ba63c3c3c..aa9d4846e8 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 3ba63c3c3cb72950adc4c9699fcfa1a72796a041
+Subproject commit aa9d4846e80fad133e7af19aba99cefa04cb8b7b

From f5a87ec7db3445f3e3183cc06fa7cf67a94133af Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 16 Feb 2024 23:26:14 +0800
Subject: [PATCH 050/132] Update submodule cudf to
 45614e2e372ea420700a9cbe12cf25f8322ab39d (#1792)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index aa9d4846e8..45614e2e37 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit aa9d4846e80fad133e7af19aba99cefa04cb8b7b
+Subproject commit 45614e2e372ea420700a9cbe12cf25f8322ab39d

From 188b11462a91616fc2ce143931e3dfc41e84a1e9 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 20 Feb 2024 05:31:03 +0800
Subject: [PATCH 051/132] Update submodule cudf to
 6a9cefdedd0b17a229cc2227c8604e49e7c65d12 (#1793)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 45614e2e37..6a9cefdedd 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 45614e2e372ea420700a9cbe12cf25f8322ab39d
+Subproject commit 6a9cefdedd0b17a229cc2227c8604e49e7c65d12

From 08bfea5517cb345527939285c21d418e18335eee Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 20 Feb 2024 12:08:55 +0800
Subject: [PATCH 052/132] Update submodule cudf to
 634b4cbb6a7dccff86cec4b21d7a39e66d210941 (#1794)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 6a9cefdedd..634b4cbb6a 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 6a9cefdedd0b17a229cc2227c8604e49e7c65d12
+Subproject commit 634b4cbb6a7dccff86cec4b21d7a39e66d210941

From efd473c512c109417f0b7d70093253c1c5866ccf Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 20 Feb 2024 23:26:50 +0800
Subject: [PATCH 053/132] Update submodule cudf to
 c0e370b271849ba5fe79ea324dfb9e4eadeb746c (#1795)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 634b4cbb6a..c0e370b271 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 634b4cbb6a7dccff86cec4b21d7a39e66d210941
+Subproject commit c0e370b271849ba5fe79ea324dfb9e4eadeb746c

From 6e6763cffef0bf753a8a30c3601910f18e6229ab Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 21 Feb 2024 06:06:41 +0800
Subject: [PATCH 054/132] Update submodule cudf to
 44686ca390f766e51cc0c1c3a08a422fc867b061 (#1796)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index c0e370b271..44686ca390 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit c0e370b271849ba5fe79ea324dfb9e4eadeb746c
+Subproject commit 44686ca390f766e51cc0c1c3a08a422fc867b061

From 774e29f0a4deed6136f0d555b4f6120534c13cdc Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 21 Feb 2024 12:11:09 +0800
Subject: [PATCH 055/132] Update submodule cudf to
 8ea716b6202d7d5093e63808d7518717ec23f7d0 (#1797)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 44686ca390..8ea716b620 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 44686ca390f766e51cc0c1c3a08a422fc867b061
+Subproject commit 8ea716b6202d7d5093e63808d7518717ec23f7d0

From b05c5ae95f0b0164d9ce32ee818e0c33d8008de5 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 21 Feb 2024 23:32:15 +0800
Subject: [PATCH 056/132] Update submodule cudf to
 14b149ac0f1fcc085cb492a2cbcfebc26ca6f516 (#1798)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 8ea716b620..14b149ac0f 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 8ea716b6202d7d5093e63808d7518717ec23f7d0
+Subproject commit 14b149ac0f1fcc085cb492a2cbcfebc26ca6f516

From a32c8b43e4b061c33fe031478609de8e9796b9c8 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 22 Feb 2024 05:28:46 +0800
Subject: [PATCH 057/132] Update submodule cudf to
 d05332308bac4a7aecc12b6ace38fc6cdec5a6a1 (#1799)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 14b149ac0f..d05332308b 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 14b149ac0f1fcc085cb492a2cbcfebc26ca6f516
+Subproject commit d05332308bac4a7aecc12b6ace38fc6cdec5a6a1

From 9794e427b522d32717899bec0887803084c46432 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 22 Feb 2024 11:29:11 +0800
Subject: [PATCH 058/132] Update submodule cudf to
 c8dc33c4470bab91d5ba38a311afde20827de8fc (#1800)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index d05332308b..c8dc33c447 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit d05332308bac4a7aecc12b6ace38fc6cdec5a6a1
+Subproject commit c8dc33c4470bab91d5ba38a311afde20827de8fc

From 49892d58a13ae520ca95d3db6fda2c40f89c9eac Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 22 Feb 2024 22:09:19 +0800
Subject: [PATCH 059/132] Update submodule cudf to
 90b763cc666c424f919ec8dcb1a0ccb064dde35e (#1801)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index c8dc33c447..90b763cc66 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit c8dc33c4470bab91d5ba38a311afde20827de8fc
+Subproject commit 90b763cc666c424f919ec8dcb1a0ccb064dde35e

From 93767484cc8d9fc002e710d1ffb8a81f6ecaaaae Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 22 Feb 2024 23:26:45 +0800
Subject: [PATCH 060/132] Update submodule cudf to
 6f6e521257dce5732eea7b6b9d56243f8b0a69cc (#1802)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 90b763cc66..6f6e521257 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 90b763cc666c424f919ec8dcb1a0ccb064dde35e
+Subproject commit 6f6e521257dce5732eea7b6b9d56243f8b0a69cc

From 62bfb492f560f53c7abcf27f5065a19edd5c3b9b Mon Sep 17 00:00:00 2001
From: Jason Lowe <jlowe@nvidia.com>
Date: Fri, 23 Feb 2024 14:00:56 -0600
Subject: [PATCH 061/132] Fix build after rename of cudf/fetch_rapids.cmake
 (#1804)

Signed-off-by: Jason Lowe <jlowe@nvidia.com>
---
 src/main/cpp/CMakeLists.txt                    |  2 +-
 src/main/cpp/benchmarks/bloom_filter.cu        | 11 +++++------
 .../cpp/benchmarks/cast_string_to_float.cpp    | 10 +++++-----
 src/main/cpp/benchmarks/parse_uri.cpp          | 14 +++++++-------
 src/main/cpp/benchmarks/row_conversion.cpp     | 10 +++++-----
 src/main/cpp/faultinj/faultinj.cu              |  9 +++++----
 src/main/cpp/src/BloomFilterJni.cpp            |  5 ++---
 src/main/cpp/src/CastStringJni.cpp             | 10 +++++-----
 src/main/cpp/src/HashJni.cpp                   |  5 ++---
 src/main/cpp/src/MapUtilsJni.cpp               |  6 +++---
 src/main/cpp/src/NativeParquetJni.cpp          | 14 +++++++-------
 src/main/cpp/src/SparkResourceAdaptorJni.cpp   | 18 +++++++++---------
 src/main/cpp/src/ZOrderJni.cpp                 |  5 ++---
 src/main/cpp/src/bloom_filter.cu               |  5 ++---
 src/main/cpp/src/bloom_filter.hpp              |  3 ++-
 src/main/cpp/src/cast_decimal_to_string.cu     | 10 +++++-----
 src/main/cpp/src/cast_string.cu                |  9 ++++-----
 src/main/cpp/src/cast_string_to_float.cu       |  3 ++-
 src/main/cpp/src/datetime_rebase.cu            |  5 ++---
 src/main/cpp/src/decimal_utils.cu              |  3 ++-
 src/main/cpp/src/map_utils.cu                  |  1 -
 src/main/cpp/src/map_utils.hpp                 |  7 ++++---
 src/main/cpp/src/murmur_hash.cu                |  5 ++---
 src/main/cpp/src/timezones.cu                  |  6 +++---
 src/main/cpp/src/xxhash64.cu                   |  5 ++---
 src/main/cpp/src/zorder.cu                     |  5 ++---
 src/main/cpp/src/zorder.hpp                    |  7 ++++---
 src/main/cpp/tests/cast_decimal_to_string.cpp  |  6 +++---
 src/main/cpp/tests/cast_float_to_string.cpp    |  6 +++---
 src/main/cpp/tests/cast_string.cpp             |  6 +++---
 src/main/cpp/tests/datetime_rebase.cpp         |  9 +++++----
 src/main/cpp/tests/hash.cpp                    | 10 +++++-----
 src/main/cpp/tests/parse_uri.cpp               |  6 +++---
 src/main/cpp/tests/utilities.cpp               |  9 +++++----
 thirdparty/cudf                                |  2 +-
 35 files changed, 122 insertions(+), 125 deletions(-)

diff --git a/src/main/cpp/CMakeLists.txt b/src/main/cpp/CMakeLists.txt
index 3ac9703bf7..2a5a456a98 100644
--- a/src/main/cpp/CMakeLists.txt
+++ b/src/main/cpp/CMakeLists.txt
@@ -14,7 +14,7 @@
 
 cmake_minimum_required(VERSION 3.20.1 FATAL_ERROR)
 
-include(../../../thirdparty/cudf/fetch_rapids.cmake)
+include(../../../thirdparty/cudf/rapids_config.cmake)
 include(rapids-cmake)
 include(rapids-cpm)
 include(rapids-cuda)
diff --git a/src/main/cpp/benchmarks/bloom_filter.cu b/src/main/cpp/benchmarks/bloom_filter.cu
index 668fd90eef..d45068001b 100644
--- a/src/main/cpp/benchmarks/bloom_filter.cu
+++ b/src/main/cpp/benchmarks/bloom_filter.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,15 +14,14 @@
  * limitations under the License.
  */
 
-#include <bloom_filter.hpp>
-#include <hash.cuh>
-
 #include <benchmarks/common/generate_input.hpp>
 
-#include <nvbench/nvbench.cuh>
-
 #include <cudf_test/column_utilities.hpp>
 
+#include <bloom_filter.hpp>
+#include <hash.cuh>
+#include <nvbench/nvbench.cuh>
+
 static void bloom_filter_put(nvbench::state& state)
 {
   constexpr int num_rows   = 150'000'000;
diff --git a/src/main/cpp/benchmarks/cast_string_to_float.cpp b/src/main/cpp/benchmarks/cast_string_to_float.cpp
index d94f9d26a0..e74eb4a4c6 100644
--- a/src/main/cpp/benchmarks/cast_string_to_float.cpp
+++ b/src/main/cpp/benchmarks/cast_string_to_float.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-#include <cast_string.hpp>
-
 #include <benchmarks/common/generate_input.hpp>
 
-#include <nvbench/nvbench.cuh>
+#include <cudf_test/column_utilities.hpp>
 
 #include <cudf/strings/convert/convert_floats.hpp>
 #include <cudf/strings/strings_column_view.hpp>
-#include <cudf_test/column_utilities.hpp>
+
+#include <cast_string.hpp>
+#include <nvbench/nvbench.cuh>
 
 void string_to_float(nvbench::state& state)
 {
diff --git a/src/main/cpp/benchmarks/parse_uri.cpp b/src/main/cpp/benchmarks/parse_uri.cpp
index 26e46117d8..03166f3c3e 100644
--- a/src/main/cpp/benchmarks/parse_uri.cpp
+++ b/src/main/cpp/benchmarks/parse_uri.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
-#include <parse_uri.hpp>
-
 #include <benchmarks/common/generate_input.hpp>
 
-#include <nvbench/nvbench.cuh>
-
-#include <cudf/filling.hpp>
-#include <cudf/strings/strings_column_view.hpp>
 #include <cudf_test/column_utilities.hpp>
 #include <cudf_test/column_wrapper.hpp>
 #include <cudf_test/default_stream.hpp>
 
+#include <cudf/filling.hpp>
+#include <cudf/strings/strings_column_view.hpp>
+
+#include <nvbench/nvbench.cuh>
+#include <parse_uri.hpp>
+
 static void bench_random_parse_uri(nvbench::state& state)
 {
   cudf::size_type const n_rows{(cudf::size_type)state.get_int64("num_rows")};
diff --git a/src/main/cpp/benchmarks/row_conversion.cpp b/src/main/cpp/benchmarks/row_conversion.cpp
index b8694fbcdf..515891d4a2 100644
--- a/src/main/cpp/benchmarks/row_conversion.cpp
+++ b/src/main/cpp/benchmarks/row_conversion.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-#include <row_conversion.hpp>
-
 #include <benchmarks/common/generate_input.hpp>
 
-#include <nvbench/nvbench.cuh>
+#include <cudf_test/column_utilities.hpp>
 
 #include <cudf/lists/lists_column_view.hpp>
 #include <cudf/strings/strings_column_view.hpp>
-#include <cudf_test/column_utilities.hpp>
+
+#include <nvbench/nvbench.cuh>
+#include <row_conversion.hpp>
 
 void fixed_width(nvbench::state& state)
 {
diff --git a/src/main/cpp/faultinj/faultinj.cu b/src/main/cpp/faultinj/faultinj.cu
index 6903ebf446..13065a81ed 100644
--- a/src/main/cpp/faultinj/faultinj.cu
+++ b/src/main/cpp/faultinj/faultinj.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,19 +14,20 @@
  * limitations under the License.
  */
 
-#include <assert.h>
 #include <cuda.h>
+
+#include <assert.h>
 #include <cupti.h>
+#include <pthread.h>
+
 #include <exception>
 #include <iostream>
 #include <map>
-#include <pthread.h>
 
 // thread-safe ptree
 #define BOOST_SPIRIT_THREADSAFE
 #include <boost/property_tree/json_parser.hpp>
 #include <boost/property_tree/ptree.hpp>
-
 #include <spdlog/spdlog.h>
 #include <sys/inotify.h>
 #include <sys/time.h>
diff --git a/src/main/cpp/src/BloomFilterJni.cpp b/src/main/cpp/src/BloomFilterJni.cpp
index 90c696577a..5acdf8a107 100644
--- a/src/main/cpp/src/BloomFilterJni.cpp
+++ b/src/main/cpp/src/BloomFilterJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,11 +15,10 @@
  */
 
 #include "bloom_filter.hpp"
-#include "utilities.hpp"
-
 #include "cudf_jni_apis.hpp"
 #include "dtype_utils.hpp"
 #include "jni_utils.hpp"
+#include "utilities.hpp"
 
 extern "C" {
 
diff --git a/src/main/cpp/src/CastStringJni.cpp b/src/main/cpp/src/CastStringJni.cpp
index b7d898a0c8..e570529cb6 100644
--- a/src/main/cpp/src/CastStringJni.cpp
+++ b/src/main/cpp/src/CastStringJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,6 +15,10 @@
  */
 
 #include "cast_string.hpp"
+#include "cudf_jni_apis.hpp"
+#include "dtype_utils.hpp"
+#include "jni_utils.hpp"
+
 #include <cudf/binaryop.hpp>
 #include <cudf/column/column_factories.hpp>
 #include <cudf/copying.hpp>
@@ -29,10 +33,6 @@
 #include <cudf/transform.hpp>
 #include <cudf/unary.hpp>
 
-#include "cudf_jni_apis.hpp"
-#include "dtype_utils.hpp"
-#include "jni_utils.hpp"
-
 constexpr char const* JNI_CAST_ERROR_CLASS = "com/nvidia/spark/rapids/jni/CastException";
 
 #define CATCH_CAST_EXCEPTION(env, ret_val)                                                \
diff --git a/src/main/cpp/src/HashJni.cpp b/src/main/cpp/src/HashJni.cpp
index d106da2b61..9e556cdd2d 100644
--- a/src/main/cpp/src/HashJni.cpp
+++ b/src/main/cpp/src/HashJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,9 +16,8 @@
 
 #include "cudf_jni_apis.hpp"
 #include "dtype_utils.hpp"
-#include "jni_utils.hpp"
-
 #include "hash.cuh"
+#include "jni_utils.hpp"
 
 extern "C" {
 
diff --git a/src/main/cpp/src/MapUtilsJni.cpp b/src/main/cpp/src/MapUtilsJni.cpp
index dc02d04370..0fc5f3c280 100644
--- a/src/main/cpp/src/MapUtilsJni.cpp
+++ b/src/main/cpp/src/MapUtilsJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
+#include "map_utils.hpp"
+
 #include <cudf_jni_apis.hpp>
 #include <dtype_utils.hpp>
 
-#include "map_utils.hpp"
-
 extern "C" {
 
 JNIEXPORT jlong JNICALL Java_com_nvidia_spark_rapids_jni_MapUtils_extractRawMapFromJsonString(
diff --git a/src/main/cpp/src/NativeParquetJni.cpp b/src/main/cpp/src/NativeParquetJni.cpp
index 9c8674e800..2a1c00b86e 100644
--- a/src/main/cpp/src/NativeParquetJni.cpp
+++ b/src/main/cpp/src/NativeParquetJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,15 +24,15 @@
 // This came from the parquet code itself...
 #define SIGNED_RIGHT_SHIFT_IS  1
 #define ARITHMETIC_RIGHT_SHIFT 1
-#include <thrift/TApplicationException.h>
-#include <thrift/protocol/TCompactProtocol.h>
-#include <thrift/transport/TBufferTransports.h>
+#include "cudf_jni_apis.hpp"
+#include "jni_utils.hpp"
 
 #include <cudf/detail/nvtx/ranges.hpp>
-#include <generated/parquet_types.h>
 
-#include "cudf_jni_apis.hpp"
-#include "jni_utils.hpp"
+#include <generated/parquet_types.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TCompactProtocol.h>
+#include <thrift/transport/TBufferTransports.h>
 
 namespace rapids {
 namespace jni {
diff --git a/src/main/cpp/src/SparkResourceAdaptorJni.cpp b/src/main/cpp/src/SparkResourceAdaptorJni.cpp
index 2df1c7ea77..37836ca67e 100644
--- a/src/main/cpp/src/SparkResourceAdaptorJni.cpp
+++ b/src/main/cpp/src/SparkResourceAdaptorJni.cpp
@@ -14,23 +14,23 @@
  * limitations under the License.
  */
 
-#include <chrono>
-#include <exception>
-#include <map>
-#include <set>
-#include <sstream>
-#include <unordered_set>
-
-#include <pthread.h>
+#include <rmm/mr/device/device_memory_resource.hpp>
 
 #include <cudf_jni_apis.hpp>
-#include <rmm/mr/device/device_memory_resource.hpp>
+#include <pthread.h>
 #include <spdlog/common.h>
 #include <spdlog/sinks/basic_file_sink.h>
 #include <spdlog/sinks/null_sink.h>
 #include <spdlog/sinks/ostream_sink.h>
 #include <spdlog/spdlog.h>
 
+#include <chrono>
+#include <exception>
+#include <map>
+#include <set>
+#include <sstream>
+#include <unordered_set>
+
 namespace {
 
 constexpr char const* GPU_RETRY_OOM_CLASS = "com/nvidia/spark/rapids/jni/GpuRetryOOM";
diff --git a/src/main/cpp/src/ZOrderJni.cpp b/src/main/cpp/src/ZOrderJni.cpp
index 37925f86d6..5d00e57490 100644
--- a/src/main/cpp/src/ZOrderJni.cpp
+++ b/src/main/cpp/src/ZOrderJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,10 +14,9 @@
  * limitations under the License.
  */
 
-#include "zorder.hpp"
-
 #include "cudf_jni_apis.hpp"
 #include "dtype_utils.hpp"
+#include "zorder.hpp"
 
 extern "C" {
 
diff --git a/src/main/cpp/src/bloom_filter.cu b/src/main/cpp/src/bloom_filter.cu
index 6270705178..d5f868c476 100644
--- a/src/main/cpp/src/bloom_filter.cu
+++ b/src/main/cpp/src/bloom_filter.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -32,9 +32,8 @@
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/exec_policy.hpp>
 
-#include <thrust/logical.h>
-
 #include <cuda/functional>
+#include <thrust/logical.h>
 
 #include <byteswap.h>
 
diff --git a/src/main/cpp/src/bloom_filter.hpp b/src/main/cpp/src/bloom_filter.hpp
index 54170782ca..e54d26f630 100644
--- a/src/main/cpp/src/bloom_filter.hpp
+++ b/src/main/cpp/src/bloom_filter.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@
 #include <cudf/column/column_view.hpp>
 #include <cudf/scalar/scalar.hpp>
 #include <cudf/utilities/default_stream.hpp>
+
 #include <rmm/cuda_stream_view.hpp>
 
 namespace spark_rapids_jni {
diff --git a/src/main/cpp/src/cast_decimal_to_string.cu b/src/main/cpp/src/cast_decimal_to_string.cu
index 01fc5c5a92..f65b91d10d 100644
--- a/src/main/cpp/src/cast_decimal_to_string.cu
+++ b/src/main/cpp/src/cast_decimal_to_string.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,9 +28,13 @@
 #include <cudf/strings/strings_column_view.hpp>
 #include <cudf/utilities/default_stream.hpp>
 #include <cudf/utilities/type_dispatcher.hpp>
+
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/exec_policy.hpp>
 
+#include <cuda/std/climits>
+#include <cuda/std/limits>
+#include <cuda/std/type_traits>
 #include <thrust/execution_policy.h>
 #include <thrust/for_each.h>
 #include <thrust/generate.h>
@@ -38,10 +42,6 @@
 #include <thrust/optional.h>
 #include <thrust/transform.h>
 
-#include <cuda/std/climits>
-#include <cuda/std/limits>
-#include <cuda/std/type_traits>
-
 using namespace cudf;
 
 namespace spark_rapids_jni {
diff --git a/src/main/cpp/src/cast_string.cu b/src/main/cpp/src/cast_string.cu
index c2a8190062..a961981160 100644
--- a/src/main/cpp/src/cast_string.cu
+++ b/src/main/cpp/src/cast_string.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,9 +16,6 @@
 
 #include "cast_string.hpp"
 
-#include <rmm/device_scalar.hpp>
-#include <rmm/exec_policy.hpp>
-
 #include <cudf/column/column.hpp>
 #include <cudf/column/column_device_view.cuh>
 #include <cudf/detail/null_mask.hpp>
@@ -26,9 +23,11 @@
 #include <cudf/detail/utilities/integer_utils.hpp>
 #include <cudf/null_mask.hpp>
 
-#include <cub/warp/warp_reduce.cuh>
+#include <rmm/device_scalar.hpp>
+#include <rmm/exec_policy.hpp>
 
 #include <cooperative_groups.h>
+#include <cub/warp/warp_reduce.cuh>
 
 using namespace cudf;
 
diff --git a/src/main/cpp/src/cast_string_to_float.cu b/src/main/cpp/src/cast_string_to_float.cu
index 75523cd360..5c3c749f02 100644
--- a/src/main/cpp/src/cast_string_to_float.cu
+++ b/src/main/cpp/src/cast_string_to_float.cu
@@ -16,7 +16,6 @@
 
 #include "cast_string.hpp"
 
-#include <cub/warp/warp_reduce.cuh>
 #include <cudf/column/column.hpp>
 #include <cudf/column/column_factories.hpp>
 #include <cudf/detail/utilities/cuda.cuh>
@@ -26,6 +25,8 @@
 #include <cudf/strings/detail/convert/string_to_float.cuh>
 #include <cudf/utilities/bit.hpp>
 
+#include <cub/warp/warp_reduce.cuh>
+
 using namespace cudf;
 
 namespace spark_rapids_jni {
diff --git a/src/main/cpp/src/datetime_rebase.cu b/src/main/cpp/src/datetime_rebase.cu
index 8963acf491..9e8e791490 100644
--- a/src/main/cpp/src/datetime_rebase.cu
+++ b/src/main/cpp/src/datetime_rebase.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,11 +27,10 @@
 #include <rmm/exec_policy.hpp>
 
 //
+#include <cuda/functional>
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/transform.h>
 
-#include <cuda/functional>
-
 namespace {
 
 // Convert a date in Julian calendar to the number of days since epoch.
diff --git a/src/main/cpp/src/decimal_utils.cu b/src/main/cpp/src/decimal_utils.cu
index 92273ff545..6b9ae61076 100644
--- a/src/main/cpp/src/decimal_utils.cu
+++ b/src/main/cpp/src/decimal_utils.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,6 +20,7 @@
 #include <cudf/detail/null_mask.hpp>
 #include <cudf/table/table_view.hpp>
 #include <cudf/utilities/error.hpp>
+
 #include <rmm/exec_policy.hpp>
 
 #include <cmath>
diff --git a/src/main/cpp/src/map_utils.cu b/src/main/cpp/src/map_utils.cu
index 9b420e201f..6ae0b5f256 100644
--- a/src/main/cpp/src/map_utils.cu
+++ b/src/main/cpp/src/map_utils.cu
@@ -53,7 +53,6 @@
 
 //
 #include <cub/device/device_radix_sort.cuh>
-
 #include <cuda/functional>
 
 namespace spark_rapids_jni {
diff --git a/src/main/cpp/src/map_utils.hpp b/src/main/cpp/src/map_utils.hpp
index 445bc89c7b..c620b6fb95 100644
--- a/src/main/cpp/src/map_utils.hpp
+++ b/src/main/cpp/src/map_utils.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,12 +16,13 @@
 
 #pragma once
 
-#include <memory>
-
 #include <cudf/column/column_view.hpp>
 #include <cudf/utilities/default_stream.hpp>
+
 #include <rmm/cuda_stream_view.hpp>
 
+#include <memory>
+
 namespace spark_rapids_jni {
 
 std::unique_ptr<cudf::column> from_json(
diff --git a/src/main/cpp/src/murmur_hash.cu b/src/main/cpp/src/murmur_hash.cu
index 17ec120b5a..d94ca2d5bc 100644
--- a/src/main/cpp/src/murmur_hash.cu
+++ b/src/main/cpp/src/murmur_hash.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,11 +24,10 @@
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/exec_policy.hpp>
 
+#include <cuda/functional>
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/tabulate.h>
 
-#include <cuda/functional>
-
 namespace spark_rapids_jni {
 
 namespace {
diff --git a/src/main/cpp/src/timezones.cu b/src/main/cpp/src/timezones.cu
index 43fff55b3b..30f19d9df0 100644
--- a/src/main/cpp/src/timezones.cu
+++ b/src/main/cpp/src/timezones.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,11 +25,11 @@
 #include <cudf/table/table.hpp>
 #include <cudf/types.hpp>
 
-#include <thrust/binary_search.h>
-
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/exec_policy.hpp>
 
+#include <thrust/binary_search.h>
+
 using column                   = cudf::column;
 using column_device_view       = cudf::column_device_view;
 using column_view              = cudf::column_view;
diff --git a/src/main/cpp/src/xxhash64.cu b/src/main/cpp/src/xxhash64.cu
index 8c0b1b8766..78cc4651bd 100644
--- a/src/main/cpp/src/xxhash64.cu
+++ b/src/main/cpp/src/xxhash64.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,9 +23,8 @@
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/exec_policy.hpp>
 
-#include <thrust/tabulate.h>
-
 #include <cuda/functional>
+#include <thrust/tabulate.h>
 
 namespace spark_rapids_jni {
 
diff --git a/src/main/cpp/src/zorder.cu b/src/main/cpp/src/zorder.cu
index f9c2d4da07..405b046528 100644
--- a/src/main/cpp/src/zorder.cu
+++ b/src/main/cpp/src/zorder.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,12 +24,11 @@
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/exec_policy.hpp>
 
+#include <cuda/functional>
 #include <thrust/for_each.h>
 #include <thrust/iterator/constant_iterator.h>
 #include <thrust/iterator/counting_iterator.h>
 
-#include <cuda/functional>
-
 namespace {
 
 // pretends to be an array of uint32_t, but really only stores
diff --git a/src/main/cpp/src/zorder.hpp b/src/main/cpp/src/zorder.hpp
index 9268f5b71e..c3fffc9b48 100644
--- a/src/main/cpp/src/zorder.hpp
+++ b/src/main/cpp/src/zorder.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,12 +16,13 @@
 
 #pragma once
 
-#include <memory>
-
 #include <cudf/lists/lists_column_view.hpp>
 #include <cudf/table/table_view.hpp>
+
 #include <rmm/cuda_stream_view.hpp>
 
+#include <memory>
+
 namespace spark_rapids_jni {
 
 std::unique_ptr<cudf::column> interleave_bits(
diff --git a/src/main/cpp/tests/cast_decimal_to_string.cpp b/src/main/cpp/tests/cast_decimal_to_string.cpp
index ba1aaf05c8..b73afb103a 100644
--- a/src/main/cpp/tests/cast_decimal_to_string.cpp
+++ b/src/main/cpp/tests/cast_decimal_to_string.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-#include <cast_string.hpp>
-
 #include <cudf_test/base_fixture.hpp>
 #include <cudf_test/column_wrapper.hpp>
 #include <cudf_test/iterator_utilities.hpp>
@@ -26,6 +24,8 @@
 
 #include <rmm/device_uvector.hpp>
 
+#include <cast_string.hpp>
+
 #include <limits>
 
 using namespace cudf;
diff --git a/src/main/cpp/tests/cast_float_to_string.cpp b/src/main/cpp/tests/cast_float_to_string.cpp
index 1ae066fe42..a118ec7fe4 100644
--- a/src/main/cpp/tests/cast_float_to_string.cpp
+++ b/src/main/cpp/tests/cast_float_to_string.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-#include <cast_string.hpp>
-
 #include <cudf_test/base_fixture.hpp>
 #include <cudf_test/column_wrapper.hpp>
 
 #include <rmm/device_uvector.hpp>
 
+#include <cast_string.hpp>
+
 #include <limits>
 
 using namespace cudf;
diff --git a/src/main/cpp/tests/cast_string.cpp b/src/main/cpp/tests/cast_string.cpp
index 1f7aaaad21..efad547869 100644
--- a/src/main/cpp/tests/cast_string.cpp
+++ b/src/main/cpp/tests/cast_string.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-#include <cast_string.hpp>
-
 #include <cudf_test/base_fixture.hpp>
 #include <cudf_test/column_wrapper.hpp>
 #include <cudf_test/iterator_utilities.hpp>
@@ -26,6 +24,8 @@
 
 #include <rmm/device_uvector.hpp>
 
+#include <cast_string.hpp>
+
 #include <limits>
 
 using namespace cudf;
diff --git a/src/main/cpp/tests/datetime_rebase.cpp b/src/main/cpp/tests/datetime_rebase.cpp
index 4fbf45e09d..8ac1ed45f9 100644
--- a/src/main/cpp/tests/datetime_rebase.cpp
+++ b/src/main/cpp/tests/datetime_rebase.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,13 +17,14 @@
 #include <datetime_rebase.hpp>
 //
 
+#include <cudf_test/base_fixture.hpp>
+#include <cudf_test/column_utilities.hpp>
+#include <cudf_test/column_wrapper.hpp>
+
 #include <cudf/strings/convert/convert_datetime.hpp>
 #include <cudf/strings/strings_column_view.hpp>
 #include <cudf/unary.hpp>
 #include <cudf/wrappers/timestamps.hpp>
-#include <cudf_test/base_fixture.hpp>
-#include <cudf_test/column_utilities.hpp>
-#include <cudf_test/column_wrapper.hpp>
 
 using days_col = cudf::test::fixed_width_column_wrapper<cudf::timestamp_D, cudf::timestamp_D::rep>;
 using micros_col =
diff --git a/src/main/cpp/tests/hash.cpp b/src/main/cpp/tests/hash.cpp
index 5f6a71ab29..265603a9af 100644
--- a/src/main/cpp/tests/hash.cpp
+++ b/src/main/cpp/tests/hash.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,9 +14,7 @@
  * limitations under the License.
  */
 
-#include <cudf/detail/iterator.cuh>
-#include <cudf/fixed_point/fixed_point.hpp>
-#include <cudf/hashing.hpp>
+#include "hash.cuh"
 
 #include <cudf_test/base_fixture.hpp>
 #include <cudf_test/column_utilities.hpp>
@@ -24,7 +22,9 @@
 #include <cudf_test/iterator_utilities.hpp>
 #include <cudf_test/type_lists.hpp>
 
-#include "hash.cuh"
+#include <cudf/detail/iterator.cuh>
+#include <cudf/fixed_point/fixed_point.hpp>
+#include <cudf/hashing.hpp>
 
 constexpr cudf::test::debug_output_level verbosity{cudf::test::debug_output_level::ALL_ERRORS};
 
diff --git a/src/main/cpp/tests/parse_uri.cpp b/src/main/cpp/tests/parse_uri.cpp
index 09f238e18c..a042ff46e9 100644
--- a/src/main/cpp/tests/parse_uri.cpp
+++ b/src/main/cpp/tests/parse_uri.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-#include <parse_uri.hpp>
-
 #include <cudf_test/base_fixture.hpp>
 #include <cudf_test/column_utilities.hpp>
 #include <cudf_test/column_wrapper.hpp>
 #include <cudf_test/debug_utilities.hpp>
 #include <cudf_test/table_utilities.hpp>
 
+#include <parse_uri.hpp>
+
 struct ParseURIProtocolTests : public cudf::test::BaseFixture {};
 struct ParseURIHostTests : public cudf::test::BaseFixture {};
 struct ParseURIQueryTests : public cudf::test::BaseFixture {};
diff --git a/src/main/cpp/tests/utilities.cpp b/src/main/cpp/tests/utilities.cpp
index 72b16543f6..19b53c2925 100644
--- a/src/main/cpp/tests/utilities.cpp
+++ b/src/main/cpp/tests/utilities.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,12 +16,13 @@
 
 #include "utilities.hpp"
 
-#include <cudf/types.hpp>
+#include "gtest/gtest.h"
+
 #include <cudf_test/base_fixture.hpp>
 
-#include <rmm/device_uvector.hpp>
+#include <cudf/types.hpp>
 
-#include "gtest/gtest.h"
+#include <rmm/device_uvector.hpp>
 
 class UtilitiesTest : public cudf::test::BaseFixture {};
 
diff --git a/thirdparty/cudf b/thirdparty/cudf
index 6f6e521257..ee3c7699bb 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 6f6e521257dce5732eea7b6b9d56243f8b0a69cc
+Subproject commit ee3c7699bbae4955e68abd13a522ba87c9ffd28c

From b66d3d2a25f4ef2ac78578c8fa0ad51c9c70c65f Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Sat, 24 Feb 2024 05:26:32 +0800
Subject: [PATCH 062/132] Update submodule cudf to
 71c990955ab57dcb1aec0efad9630c91404b2a57 (#1805)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index ee3c7699bb..71c990955a 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit ee3c7699bbae4955e68abd13a522ba87c9ffd28c
+Subproject commit 71c990955ab57dcb1aec0efad9630c91404b2a57

From 6ad7be7414888f14ef3beedbbbec495564065451 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Sat, 24 Feb 2024 17:25:55 +0800
Subject: [PATCH 063/132] Update submodule cudf to
 c37367ee22f12cc59c7ec7ed530596b82870334c (#1806)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 71c990955a..c37367ee22 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 71c990955ab57dcb1aec0efad9630c91404b2a57
+Subproject commit c37367ee22f12cc59c7ec7ed530596b82870334c

From 1583e74c65e25a56185dc152bb8b15b645c3bfdd Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Mon, 26 Feb 2024 17:33:50 +0800
Subject: [PATCH 064/132] Update submodule cudf to
 7d2da0e5bd9bc178ab394506e58207667c59eedb (#1807)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index c37367ee22..7d2da0e5bd 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit c37367ee22f12cc59c7ec7ed530596b82870334c
+Subproject commit 7d2da0e5bd9bc178ab394506e58207667c59eedb

From 7dfa7ae559c2af7445135ed3cc11e6b6d83f6bfc Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 27 Feb 2024 05:30:14 +0800
Subject: [PATCH 065/132] Update submodule cudf to
 e03623ae2ddbc4326201c30f15540ac04d78c0d6 (#1808)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 7d2da0e5bd..e03623ae2d 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 7d2da0e5bd9bc178ab394506e58207667c59eedb
+Subproject commit e03623ae2ddbc4326201c30f15540ac04d78c0d6

From 4dd6fbc0bfe96996bdc12cc3fb430e61958d017b Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 28 Feb 2024 05:29:51 +0800
Subject: [PATCH 066/132] Update submodule cudf to
 ef20ef9af942d840effd8ac16f8b302a8e4b1dd4 (#1809)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index e03623ae2d..ef20ef9af9 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit e03623ae2ddbc4326201c30f15540ac04d78c0d6
+Subproject commit ef20ef9af942d840effd8ac16f8b302a8e4b1dd4

From b1e51c7a17ac9793c1025339cc2f0815dde01c90 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 28 Feb 2024 11:37:40 +0800
Subject: [PATCH 067/132] Update submodule cudf to
 1719cda0b18bf3f15426f827fc49e23f0ec3bd40 (#1811)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index ef20ef9af9..1719cda0b1 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit ef20ef9af942d840effd8ac16f8b302a8e4b1dd4
+Subproject commit 1719cda0b18bf3f15426f827fc49e23f0ec3bd40

From 7c099dbf0fcfbdfc520999b514d168090fd1427e Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 28 Feb 2024 04:25:33 +0000
Subject: [PATCH 068/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index dd34fdbe35..1719cda0b1 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit dd34fdbe35e68ba56a2183f11ed822ddaa6c927b
+Subproject commit 1719cda0b18bf3f15426f827fc49e23f0ec3bd40

From 49412dc421424047684a40d3e505841b654b22a1 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 29 Feb 2024 05:28:05 +0800
Subject: [PATCH 069/132] Update submodule cudf to
 896b5bced6597e81f3a9e96e5b6bcc72cb364e68 (#1815)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 1719cda0b1..896b5bced6 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 1719cda0b18bf3f15426f827fc49e23f0ec3bd40
+Subproject commit 896b5bced6597e81f3a9e96e5b6bcc72cb364e68

From 0610553644e8e1c858f129f03681230e350f81eb Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 29 Feb 2024 12:04:39 +0800
Subject: [PATCH 070/132] Update submodule cudf to
 8507b3dfe44794cd549222598320d9cf25c6e34c (#1816)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 896b5bced6..8507b3dfe4 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 896b5bced6597e81f3a9e96e5b6bcc72cb364e68
+Subproject commit 8507b3dfe44794cd549222598320d9cf25c6e34c

From e12012c836e6e24ce4e473b491117e4bcf23d772 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 29 Feb 2024 17:27:27 +0800
Subject: [PATCH 071/132] Update submodule cudf to
 f7e486043c30810625fe2d13f5b20d60f90b8d2e (#1817)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 8507b3dfe4..f7e486043c 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 8507b3dfe44794cd549222598320d9cf25c6e34c
+Subproject commit f7e486043c30810625fe2d13f5b20d60f90b8d2e

From 9274bd5d01d9d456b18dd3843c7f304ecfc1ac6b Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 1 Mar 2024 00:05:14 +0800
Subject: [PATCH 072/132] Update submodule cudf to
 1a3b7890e1f110e93082308546eccbeae8a4784a (#1818)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index f7e486043c..1a3b7890e1 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit f7e486043c30810625fe2d13f5b20d60f90b8d2e
+Subproject commit 1a3b7890e1f110e93082308546eccbeae8a4784a

From 18745a63fd32fc296d42a35a10f9385aefe52195 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Sun, 3 Mar 2024 21:42:23 +0800
Subject: [PATCH 073/132] [submodule-sync] bot-submodule-sync-branch-24.02 to
 branch-24.02 [skip ci] [bot] (#1821)

* checkout to tag

* Update submodule cudf to v24.04.00a

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

---------

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Co-authored-by: Tim Liu <timl@nvidia.com>
---
 ci/submodule-sync.sh | 18 ++++++++++++++----
 thirdparty/cudf      |  2 +-
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/ci/submodule-sync.sh b/ci/submodule-sync.sh
index 2b8b186152..e951c38d40 100755
--- a/ci/submodule-sync.sh
+++ b/ci/submodule-sync.sh
@@ -22,7 +22,7 @@
 
 set -ex
 
-OWNER=${OWNER:-"NVIDIA"}
+OWNER=${OWNER:-"NVTIMLIU"}
 REPO=${REPO:-"spark-rapids-jni"}
 PARALLEL_LEVEL=${PARALLEL_LEVEL:-4}
 REPO_LOC="github.com/${OWNER}/${REPO}.git"
@@ -50,7 +50,13 @@ else
 fi
 
 # sync up cudf from remote
-git submodule update --remote --merge
+if [ -n "$CUDF_TAG" ]; then
+  pushd thirdparty/cudf
+  git checkout tags/$CUDF_TAG
+  popd
+else
+  git submodule update --remote --merge
+fi
 cudf_sha=$(git -C thirdparty/cudf rev-parse HEAD)
 if [[ "${cudf_sha}" == "${cudf_prev_sha}" ]]; then
   echo "Submodule is up to date."
@@ -59,14 +65,18 @@ fi
 
 echo "Try update cudf submodule to ${cudf_sha}..."
 git add .
-git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${cudf_sha}"
+if [ -n "$CUDF_TAG" ]; then
+  git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${CUDF_TAG}"
+else
+  git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${cudf_sha}"
+fi
 sha=$(git rev-parse HEAD)
 
 echo "Test against ${cudf_sha}..."
 
 MVN="mvn -Dmaven.wagon.http.retryHandler.count=3 -B"
 set +e
-${MVN} verify ${MVN_MIRROR} \
+echo ${MVN} verify ${MVN_MIRROR} \
   -DCPP_PARALLEL_LEVEL=${PARALLEL_LEVEL} \
   -Dlibcudf.build.configure=true \
   -DUSE_GDS=ON -Dtest=*,!CuFileTest,!CudaFatalTest,!ColumnViewNonEmptyNullsTest \
diff --git a/thirdparty/cudf b/thirdparty/cudf
index dd34fdbe35..46119314c3 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit dd34fdbe35e68ba56a2183f11ed822ddaa6c927b
+Subproject commit 46119314c3a7a7621a476d730d0441031398f74c

From 7485bda3ada08837f114f39ae8a94da81b71321f Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Sun, 3 Mar 2024 13:42:34 +0000
Subject: [PATCH 074/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 46119314c3..1a3b7890e1 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 46119314c3a7a7621a476d730d0441031398f74c
+Subproject commit 1a3b7890e1f110e93082308546eccbeae8a4784a

From 3f5371a0f870b254056809d8c08b286400401f0b Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Mon, 4 Mar 2024 16:31:56 +0800
Subject: [PATCH 075/132] [submodule-sync] bot-submodule-sync-branch-24.04 to
 branch-24.04 [skip ci] [bot] (#1819)

* Update submodule cudf to a9e41e73505876b171ca620c52a8638dae9896fd

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

* Update submodule cudf to 56a3b8f6516f830d836b50cc0d93ae67c4db9613

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

* Update submodule cudf to 3b228e2c6d3ec39fcba553c63d53a56760dc1ca6

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

* Update submodule cudf to e60aad110efcd94003ad78d0f46ac94e531bd1c0

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

---------

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 1a3b7890e1..e60aad110e 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 1a3b7890e1f110e93082308546eccbeae8a4784a
+Subproject commit e60aad110efcd94003ad78d0f46ac94e531bd1c0

From d5efccbf067de2e93bcae0ca92111b318360655d Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 5 Mar 2024 04:32:22 +0800
Subject: [PATCH 076/132] Update submodule cudf to
 d158ccdbe651952bd649cb0f17c41467c5209824 (#1825)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index e60aad110e..d158ccdbe6 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit e60aad110efcd94003ad78d0f46ac94e531bd1c0
+Subproject commit d158ccdbe651952bd649cb0f17c41467c5209824

From dc8b36d629148c661e407f0dc9db8fc5db92ef9f Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 5 Mar 2024 10:32:28 +0800
Subject: [PATCH 077/132] Update submodule cudf to
 3571291c533412f8efa4c5d41caa865564b5391b (#1826)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index d158ccdbe6..3571291c53 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit d158ccdbe651952bd649cb0f17c41467c5209824
+Subproject commit 3571291c533412f8efa4c5d41caa865564b5391b

From f1e37af900d0ddc02f0211b5ff7548610395d1da Mon Sep 17 00:00:00 2001
From: Tim Liu <timl@nvidia.com>
Date: Tue, 5 Mar 2024 16:22:29 +0800
Subject: [PATCH 078/132] =?UTF-8?q?Revert=20"[submodule-sync]=20bot-submod?=
 =?UTF-8?q?ule-sync-branch-24.02=20to=20branch-24.02=20[ski=E2=80=A6"=20(#?=
 =?UTF-8?q?1828)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This reverts commit 18745a63fd32fc296d42a35a10f9385aefe52195.
---
 ci/submodule-sync.sh | 18 ++++--------------
 thirdparty/cudf      |  2 +-
 2 files changed, 5 insertions(+), 15 deletions(-)

diff --git a/ci/submodule-sync.sh b/ci/submodule-sync.sh
index e951c38d40..2b8b186152 100755
--- a/ci/submodule-sync.sh
+++ b/ci/submodule-sync.sh
@@ -22,7 +22,7 @@
 
 set -ex
 
-OWNER=${OWNER:-"NVTIMLIU"}
+OWNER=${OWNER:-"NVIDIA"}
 REPO=${REPO:-"spark-rapids-jni"}
 PARALLEL_LEVEL=${PARALLEL_LEVEL:-4}
 REPO_LOC="github.com/${OWNER}/${REPO}.git"
@@ -50,13 +50,7 @@ else
 fi
 
 # sync up cudf from remote
-if [ -n "$CUDF_TAG" ]; then
-  pushd thirdparty/cudf
-  git checkout tags/$CUDF_TAG
-  popd
-else
-  git submodule update --remote --merge
-fi
+git submodule update --remote --merge
 cudf_sha=$(git -C thirdparty/cudf rev-parse HEAD)
 if [[ "${cudf_sha}" == "${cudf_prev_sha}" ]]; then
   echo "Submodule is up to date."
@@ -65,18 +59,14 @@ fi
 
 echo "Try update cudf submodule to ${cudf_sha}..."
 git add .
-if [ -n "$CUDF_TAG" ]; then
-  git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${CUDF_TAG}"
-else
-  git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${cudf_sha}"
-fi
+git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${cudf_sha}"
 sha=$(git rev-parse HEAD)
 
 echo "Test against ${cudf_sha}..."
 
 MVN="mvn -Dmaven.wagon.http.retryHandler.count=3 -B"
 set +e
-echo ${MVN} verify ${MVN_MIRROR} \
+${MVN} verify ${MVN_MIRROR} \
   -DCPP_PARALLEL_LEVEL=${PARALLEL_LEVEL} \
   -Dlibcudf.build.configure=true \
   -DUSE_GDS=ON -Dtest=*,!CuFileTest,!CudaFatalTest,!ColumnViewNonEmptyNullsTest \
diff --git a/thirdparty/cudf b/thirdparty/cudf
index 46119314c3..dd34fdbe35 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 46119314c3a7a7621a476d730d0441031398f74c
+Subproject commit dd34fdbe35e68ba56a2183f11ed822ddaa6c927b

From d9cbab9796539db921833e46fba5ec9a1fa220bb Mon Sep 17 00:00:00 2001
From: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 5 Mar 2024 08:22:41 +0000
Subject: [PATCH 079/132] Auto-merge use submodule in BASE ref

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index dd34fdbe35..3571291c53 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit dd34fdbe35e68ba56a2183f11ed822ddaa6c927b
+Subproject commit 3571291c533412f8efa4c5d41caa865564b5391b

From 536c69688482eb4ce02137a8cc4913421ef29255 Mon Sep 17 00:00:00 2001
From: Jason Lowe <jlowe@nvidia.com>
Date: Tue, 5 Mar 2024 10:51:34 -0600
Subject: [PATCH 080/132] Update to make_strings_column returning uvector
 (#1837)

* Update to make_strings_column returning uvector

Signed-off-by: Jason Lowe <jlowe@nvidia.com>

* Style fix

---------

Signed-off-by: Jason Lowe <jlowe@nvidia.com>
---
 src/main/cpp/src/cast_decimal_to_string.cu | 2 +-
 src/main/cpp/src/cast_float_to_string.cu   | 2 +-
 src/main/cpp/src/format_float.cu           | 4 ++--
 src/main/cpp/src/map_utils.cu              | 9 +++------
 thirdparty/cudf                            | 2 +-
 5 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/src/main/cpp/src/cast_decimal_to_string.cu b/src/main/cpp/src/cast_decimal_to_string.cu
index f65b91d10d..9d0e27ed59 100644
--- a/src/main/cpp/src/cast_decimal_to_string.cu
+++ b/src/main/cpp/src/cast_decimal_to_string.cu
@@ -191,7 +191,7 @@ struct dispatch_decimal_to_non_ansi_string_fn {
 
     return make_strings_column(input.size(),
                                std::move(offsets),
-                               std::move(chars->release().data.release()[0]),
+                               chars.release(),
                                input.null_count(),
                                cudf::detail::copy_bitmask(input, stream, mr));
   }
diff --git a/src/main/cpp/src/cast_float_to_string.cu b/src/main/cpp/src/cast_float_to_string.cu
index c0e0875914..78cedbbf64 100644
--- a/src/main/cpp/src/cast_float_to_string.cu
+++ b/src/main/cpp/src/cast_float_to_string.cu
@@ -88,7 +88,7 @@ struct dispatch_float_to_string_fn {
 
     return make_strings_column(strings_count,
                                std::move(offsets),
-                               std::move(chars->release().data.release()[0]),
+                               chars.release(),
                                floats.null_count(),
                                cudf::detail::copy_bitmask(floats, stream, mr));
   }
diff --git a/src/main/cpp/src/format_float.cu b/src/main/cpp/src/format_float.cu
index 3052d334aa..1d537595d7 100644
--- a/src/main/cpp/src/format_float.cu
+++ b/src/main/cpp/src/format_float.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -89,7 +89,7 @@ struct dispatch_format_float_fn {
 
     return cudf::make_strings_column(strings_count,
                                      std::move(offsets),
-                                     std::move(chars->release().data.release()[0]),
+                                     chars.release(),
                                      floats.null_count(),
                                      cudf::detail::copy_bitmask(floats, stream, mr));
   }
diff --git a/src/main/cpp/src/map_utils.cu b/src/main/cpp/src/map_utils.cu
index 6ae0b5f256..6ae54f4fe9 100644
--- a/src/main/cpp/src/map_utils.cu
+++ b/src/main/cpp/src/map_utils.cu
@@ -572,13 +572,10 @@ std::unique_ptr<cudf::column> extract_keys_or_values(
                                                                   stream);
   auto const num_extract = thrust::distance(extract_ranges.begin(), range_end);
 
-  auto children = cudf::strings::detail::make_strings_children(
+  auto [offsets, chars] = cudf::strings::detail::make_strings_children(
     substring_fn{unified_json_buff, extract_ranges}, num_extract, stream, mr);
-  return cudf::make_strings_column(num_extract,
-                                   std::move(children.first),
-                                   std::move(children.second->release().data.release()[0]),
-                                   0,
-                                   rmm::device_buffer{});
+  return cudf::make_strings_column(
+    num_extract, std::move(offsets), chars.release(), 0, rmm::device_buffer{});
 }
 
 // Compute the offsets for the final lists of Struct<String,String>.
diff --git a/thirdparty/cudf b/thirdparty/cudf
index 3571291c53..8d073e4ca0 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 3571291c533412f8efa4c5d41caa865564b5391b
+Subproject commit 8d073e4ca0a6cb9d9a4d9fe5e4e0147f01d7eb36

From 99445a7b06344270cfaa90e1f349ffb64b576a48 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 6 Mar 2024 05:32:26 +0800
Subject: [PATCH 081/132] [submodule-sync] bot-submodule-sync-branch-24.04 to
 branch-24.04 [skip ci] [bot] (#1834)

* Update submodule cudf to f804aa69ca22124f648aba70096df6f1efe27629

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

* Update submodule cudf to 8d073e4ca0a6cb9d9a4d9fe5e4e0147f01d7eb36

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

* Update submodule cudf to 176f75b1da0559c024a62a98f13ff15491f18a95

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

---------

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 8d073e4ca0..176f75b1da 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 8d073e4ca0a6cb9d9a4d9fe5e4e0147f01d7eb36
+Subproject commit 176f75b1da0559c024a62a98f13ff15491f18a95

From 5a0914758cb5d3948cd786e205b3e99a3d0a23d9 Mon Sep 17 00:00:00 2001
From: Nghia Truong <7416935+ttnghia@users.noreply.github.com>
Date: Wed, 6 Mar 2024 10:31:22 -0700
Subject: [PATCH 082/132] Move row conversion code from cudf (#1838)

* Revert "Use cuda::proclaim_return_type on device lambdas (#1662)"

This reverts commit 763406c0c407408c29c4147dd22304a13ef21470.

# Conflicts:
#	src/main/cpp/benchmarks/row_conversion.cpp
#	src/main/cpp/src/bloom_filter.cu
#	src/main/cpp/src/map_utils.cu
#	src/main/cpp/src/xxhash64.cu
#	thirdparty/cudf

Signed-off-by: Nghia Truong <nghiat@nvidia.com>

* Remove redundant header

Signed-off-by: Nghia Truong <nghiat@nvidia.com>

* Update copyright year

Signed-off-by: Nghia Truong <nghiat@nvidia.com>

---------

Signed-off-by: Nghia Truong <nghiat@nvidia.com>
---
 src/main/cpp/CMakeLists.txt                |    1 +
 src/main/cpp/benchmarks/row_conversion.cpp |   14 +-
 src/main/cpp/src/RowConversionJni.cpp      |   17 +-
 src/main/cpp/src/row_conversion.cu         | 2515 ++++++++++++++++++++
 src/main/cpp/src/row_conversion.hpp        |   53 +
 src/main/cpp/tests/CMakeLists.txt          |    5 +-
 src/main/cpp/tests/row_conversion.cpp      | 1029 ++++++++
 7 files changed, 3618 insertions(+), 16 deletions(-)
 create mode 100644 src/main/cpp/src/row_conversion.cu
 create mode 100644 src/main/cpp/src/row_conversion.hpp
 create mode 100644 src/main/cpp/tests/row_conversion.cpp

diff --git a/src/main/cpp/CMakeLists.txt b/src/main/cpp/CMakeLists.txt
index 2a5a456a98..3baf384b1e 100644
--- a/src/main/cpp/CMakeLists.txt
+++ b/src/main/cpp/CMakeLists.txt
@@ -171,6 +171,7 @@ add_library(
   src/map_utils.cu
   src/murmur_hash.cu
   src/parse_uri.cu
+  src/row_conversion.cu
   src/timezones.cu
   src/utilities.cu
   src/xxhash64.cu
diff --git a/src/main/cpp/benchmarks/row_conversion.cpp b/src/main/cpp/benchmarks/row_conversion.cpp
index 515891d4a2..ff2e11f838 100644
--- a/src/main/cpp/benchmarks/row_conversion.cpp
+++ b/src/main/cpp/benchmarks/row_conversion.cpp
@@ -48,15 +48,15 @@ void fixed_width(nvbench::state& state)
     bytes_per_row += cudf::size_of(t);
   }
 
-  auto rows = cudf::convert_to_rows_fixed_width_optimized(table->view());
+  auto rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(table->view());
 
   state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
     if (direction == "to row") {
-      auto _rows = cudf::convert_to_rows_fixed_width_optimized(table->view());
+      auto _rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(table->view());
     } else {
       for (auto const& r : rows) {
         cudf::lists_column_view const l(r->view());
-        auto out = cudf::convert_from_rows_fixed_width_optimized(l, schema);
+        auto out = spark_rapids_jni::convert_from_rows_fixed_width_optimized(l, schema);
       }
     }
   });
@@ -117,16 +117,16 @@ static void variable_or_fixed_width(nvbench::state& state)
     }
   }
 
-  auto rows = cudf::convert_to_rows(table->view());
+  auto rows = spark_rapids_jni::convert_to_rows(table->view());
 
   state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
-    auto new_rows = cudf::convert_to_rows(table->view());
+    auto new_rows = spark_rapids_jni::convert_to_rows(table->view());
     if (direction == "to row") {
-      auto _rows = cudf::convert_to_rows(table->view());
+      auto _rows = spark_rapids_jni::convert_to_rows(table->view());
     } else {
       for (auto const& r : rows) {
         cudf::lists_column_view const l(r->view());
-        auto out = cudf::convert_from_rows(l, schema);
+        auto out = spark_rapids_jni::convert_from_rows(l, schema);
       }
     }
   });
diff --git a/src/main/cpp/src/RowConversionJni.cpp b/src/main/cpp/src/RowConversionJni.cpp
index 8e900691f1..26b1138c10 100644
--- a/src/main/cpp/src/RowConversionJni.cpp
+++ b/src/main/cpp/src/RowConversionJni.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,8 +16,7 @@
 
 #include "cudf_jni_apis.hpp"
 #include "dtype_utils.hpp"
-
-#include <cudf/row_conversion.hpp>
+#include "row_conversion.hpp"
 
 extern "C" {
 
@@ -32,7 +31,7 @@ Java_com_nvidia_spark_rapids_jni_RowConversion_convertToRowsFixedWidthOptimized(
     cudf::jni::auto_set_device(env);
     cudf::table_view const* n_input_table = reinterpret_cast<cudf::table_view const*>(input_table);
     std::vector<std::unique_ptr<cudf::column>> cols =
-      cudf::convert_to_rows_fixed_width_optimized(*n_input_table);
+      spark_rapids_jni::convert_to_rows_fixed_width_optimized(*n_input_table);
     int const num_columns = cols.size();
     cudf::jni::native_jlongArray outcol_handles(env, num_columns);
     std::transform(cols.begin(), cols.end(), outcol_handles.begin(), [](auto& col) {
@@ -51,8 +50,9 @@ Java_com_nvidia_spark_rapids_jni_RowConversion_convertToRows(JNIEnv* env, jclass
   try {
     cudf::jni::auto_set_device(env);
     cudf::table_view const* n_input_table = reinterpret_cast<cudf::table_view const*>(input_table);
-    std::vector<std::unique_ptr<cudf::column>> cols = cudf::convert_to_rows(*n_input_table);
-    int const num_columns                           = cols.size();
+    std::vector<std::unique_ptr<cudf::column>> cols =
+      spark_rapids_jni::convert_to_rows(*n_input_table);
+    int const num_columns = cols.size();
     cudf::jni::native_jlongArray outcol_handles(env, num_columns);
     std::transform(cols.begin(), cols.end(), outcol_handles.begin(), [](auto& col) {
       return cudf::jni::release_as_jlong(col);
@@ -84,7 +84,7 @@ Java_com_nvidia_spark_rapids_jni_RowConversion_convertFromRowsFixedWidthOptimize
                    std::back_inserter(types_vec),
                    [](jint type, jint scale) { return cudf::jni::make_data_type(type, scale); });
     std::unique_ptr<cudf::table> result =
-      cudf::convert_from_rows_fixed_width_optimized(list_input, types_vec);
+      spark_rapids_jni::convert_from_rows_fixed_width_optimized(list_input, types_vec);
     return cudf::jni::convert_table_for_return(env, result);
   }
   CATCH_STD(env, 0);
@@ -110,7 +110,8 @@ JNIEXPORT jlongArray JNICALL Java_com_nvidia_spark_rapids_jni_RowConversion_conv
                    n_scale.begin(),
                    std::back_inserter(types_vec),
                    [](jint type, jint scale) { return cudf::jni::make_data_type(type, scale); });
-    std::unique_ptr<cudf::table> result = cudf::convert_from_rows(list_input, types_vec);
+    std::unique_ptr<cudf::table> result =
+      spark_rapids_jni::convert_from_rows(list_input, types_vec);
     return cudf::jni::convert_table_for_return(env, result);
   }
   CATCH_STD(env, 0);
diff --git a/src/main/cpp/src/row_conversion.cu b/src/main/cpp/src/row_conversion.cu
new file mode 100644
index 0000000000..3d6e767042
--- /dev/null
+++ b/src/main/cpp/src/row_conversion.cu
@@ -0,0 +1,2515 @@
+/*
+ * Copyright (c) 2020-2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "row_conversion.hpp"
+
+#include <cudf/column/column_factories.hpp>
+#include <cudf/detail/iterator.cuh>
+#include <cudf/detail/null_mask.hpp>
+#include <cudf/detail/offsets_iterator_factory.cuh>
+#include <cudf/detail/sequence.hpp>
+#include <cudf/detail/utilities/cuda.cuh>
+#include <cudf/detail/utilities/integer_utils.hpp>
+#include <cudf/detail/utilities/vector_factories.hpp>
+#include <cudf/lists/lists_column_device_view.cuh>
+#include <cudf/scalar/scalar_factories.hpp>
+#include <cudf/strings/strings_column_view.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/types.hpp>
+#include <cudf/utilities/bit.hpp>
+#include <cudf/utilities/default_stream.hpp>
+#include <cudf/utilities/error.hpp>
+#include <cudf/utilities/traits.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+#include <rmm/device_buffer.hpp>
+#include <rmm/device_uvector.hpp>
+#include <rmm/exec_policy.hpp>
+
+#include <cooperative_groups.h>
+#include <cuda/barrier>
+#include <cuda/functional>
+#include <thrust/binary_search.h>
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/iterator/discard_iterator.h>
+#include <thrust/iterator/transform_iterator.h>
+#include <thrust/scan.h>
+
+#include <algorithm>
+#include <cstdarg>
+#include <cstdint>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <optional>
+#include <tuple>
+#include <type_traits>
+
+namespace {
+
+constexpr auto JCUDF_ROW_ALIGNMENT = 8;
+
+constexpr auto MAX_BATCH_SIZE = std::numeric_limits<cudf::size_type>::max();
+
+// Number of rows each block processes in the two kernels. Tuned via nsight
+constexpr auto NUM_STRING_ROWS_PER_BLOCK_TO_ROWS   = 1024;
+constexpr auto NUM_STRING_ROWS_PER_BLOCK_FROM_ROWS = 64;
+constexpr auto MIN_STRING_BLOCKS                   = 32;
+constexpr auto MAX_STRING_BLOCKS                   = MAX_BATCH_SIZE;
+
+constexpr auto NUM_WARPS_IN_BLOCK = 32;
+
+}  // anonymous namespace
+
+// needed to suppress warning about cuda::barrier
+#pragma nv_diag_suppress static_var_with_dynamic_init
+
+using namespace cudf;
+using detail::make_device_uvector_async;
+using detail::make_device_uvector_sync;
+using rmm::device_uvector;
+
+namespace spark_rapids_jni {
+namespace detail {
+
+/*
+ * This module converts data from row-major to column-major and from column-major to row-major. It
+ * is a transpose of the data of sorts, but there are a few complicating factors. They are spelled
+ * out below:
+ *
+ * Row Batches:
+ * The row data has to fit inside a cuDF column, which limits it to 2 gigs currently. The calling
+ * code attempts to keep the data size under 2 gigs, but due to padding this isn't always the case,
+ * so being able to break this up into multiple columns is necessary. Internally, this is referred
+ * to as the row batch, which is a group of rows that will fit into this 2 gig space requirement.
+ * There are typically 1 of these batches, but there can be 2.
+ *
+ * Async Memcpy:
+ * The CUDA blocks are using memcpy_async, which allows for the device to schedule memcpy operations
+ * and then wait on them to complete at a later time with a barrier. On Ampere or later hardware
+ * there is dedicated hardware to do this copy and on pre-Ampere it should generate the same code
+ * that a hand-rolled loop would generate, so performance should be the same or better than a
+ * hand-rolled kernel.
+ *
+ * Tile Info:
+ * Each CUDA block will work on a single tile info before exiting. This single tile consumes all
+ * available shared memory. The kernel reads data into shared memory and then back out from shared
+ * memory to device memory via memcpy_async. This kernel is completely memory bound.
+ *
+ * Batch Data:
+ * This structure contains all the row batches and some book-keeping data necessary for the batches
+ * such as row numbers for the batches.
+ *
+ * Tiles:
+ * The tile info describes a tile of data to process. In a GPU with 48KB this equates to about 221
+ * bytes in each direction of a table. The tiles are kept as square as possible to attempt to
+ * coalesce memory operations. The taller a tile is the better coalescing of columns, but row
+ * coalescing suffers. The wider a tile is the better the row coalescing, but columns coalescing
+ * suffers. The code attempts to produce a square tile to balance the coalescing. It starts by
+ * figuring out the optimal byte length and then adding columns to the data until the tile is too
+ * large. Since rows are different width with different alignment requirements, this isn't typically
+ * exact. Once a width is found the tiles are generated vertically with that width and height and
+ * then the process repeats. This means all the tiles will be the same height, but will have
+ * different widths based on what columns they encompass. Tiles in a vertical row will all have the
+ * same dimensions.
+ *
+ *   --------------------------------
+ *   | 4   5.0f || True   8   3   1 |
+ *   | 3   6.0f || False  3   1   1 |
+ *   | 2   7.0f || True   7   4   1 |
+ *   | 1   8.0f || False  2   5   1 |
+ *   --------------------------------
+ *   | 0   9.0f || True   6   7   1 |
+ *   ...
+ */
+
+/**
+ * @brief The CUDA blocks work on one tile_info struct of data.
+ *        This structure defines the workspaces for the blocks.
+ *
+ */
+struct tile_info {
+  int start_col;
+  int start_row;
+  int end_col;
+  int end_row;
+  int batch_number;
+
+  __device__ inline size_type get_shared_row_size(size_type const* const col_offsets,
+                                                  size_type const* const col_sizes) const
+  {
+    // this calculation is invalid if there are holes in the data such as a variable-width column.
+    // It is wrong in a safe way in that it will say this row size is larger than it should be, so
+    // we are not losing data we are just not as efficient as we could be with shared memory. This
+    // may be a problem if the tile is computed without regard to variable width offset/length sizes
+    // in that we overrun shared memory.
+    return util::round_up_unsafe(col_offsets[end_col] + col_sizes[end_col] - col_offsets[start_col],
+                                 JCUDF_ROW_ALIGNMENT);
+  }
+
+  __device__ inline size_type num_cols() const { return end_col - start_col + 1; }
+
+  __device__ inline size_type num_rows() const { return end_row - start_row + 1; }
+};
+
+/**
+ * @brief Returning rows is done in a byte cudf column. This is limited in size by
+ *        `size_type` and so output is broken into batches of rows that fit inside
+ *        this limit.
+ *
+ */
+struct row_batch {
+  size_type num_bytes;                    // number of bytes in this batch
+  size_type row_count;                    // number of rows in the batch
+  device_uvector<size_type> row_offsets;  // offsets column of output cudf column
+};
+
+/**
+ * @brief Holds information about the batches of data to be processed
+ *
+ */
+struct batch_data {
+  device_uvector<size_type> batch_row_offsets;       // offsets to each row in incoming data
+  device_uvector<size_type> d_batch_row_boundaries;  // row numbers for the start of each batch
+  std::vector<size_type>
+    batch_row_boundaries;              // row numbers for the start of each batch: 0, 1500, 2700
+  std::vector<row_batch> row_batches;  // information about each batch such as byte count
+};
+
+/**
+ * @brief builds row size information for tables that contain strings
+ *
+ * @param tbl table from which to compute row size information
+ * @param fixed_width_and_validity_size size of fixed-width and validity data in this table
+ * @param stream cuda stream on which to operate
+ * @return pair of device vector of size_types of the row sizes of the table and a device vector of
+ * offsets into the string column
+ */
+std::pair<rmm::device_uvector<size_type>, rmm::device_uvector<cudf::detail::input_offsetalator>>
+build_string_row_offsets(table_view const& tbl,
+                         size_type fixed_width_and_validity_size,
+                         rmm::cuda_stream_view stream)
+{
+  auto const num_rows = tbl.num_rows();
+  rmm::device_uvector<size_type> d_row_sizes(num_rows, stream);
+  thrust::uninitialized_fill(rmm::exec_policy(stream), d_row_sizes.begin(), d_row_sizes.end(), 0);
+
+  auto d_offsets_iterators = [&]() {
+    std::vector<cudf::detail::input_offsetalator> offsets_iterators;
+    auto itr = thrust::make_transform_iterator(
+      tbl.begin(), [](auto const& col) -> cudf::detail::input_offsetalator {
+        return cudf::detail::offsetalator_factory::make_input_iterator(
+          strings_column_view(col).offsets(), col.offset());
+      });
+    auto stencil = thrust::make_transform_iterator(
+      tbl.begin(), [](auto const& col) -> bool { return !is_fixed_width(col.type()); });
+    thrust::copy_if(thrust::host,
+                    itr,
+                    itr + tbl.num_columns(),
+                    stencil,
+                    std::back_inserter(offsets_iterators),
+                    thrust::identity<bool>{});
+    return make_device_uvector_sync(
+      offsets_iterators, stream, rmm::mr::get_current_device_resource());
+  }();
+
+  auto const num_columns = static_cast<size_type>(d_offsets_iterators.size());
+
+  thrust::for_each(rmm::exec_policy(stream),
+                   thrust::make_counting_iterator(0),
+                   thrust::make_counting_iterator(num_columns * num_rows),
+                   [d_offsets_iterators = d_offsets_iterators.data(),
+                    num_columns,
+                    num_rows,
+                    d_row_sizes = d_row_sizes.data()] __device__(auto element_idx) {
+                     auto const row = element_idx % num_rows;
+                     auto const col = element_idx / num_rows;
+                     auto const val =
+                       d_offsets_iterators[col][row + 1] - d_offsets_iterators[col][row];
+                     atomicAdd(&d_row_sizes[row], val);
+                   });
+
+  // transform the row sizes to include fixed width size and alignment
+  thrust::transform(rmm::exec_policy(stream),
+                    d_row_sizes.begin(),
+                    d_row_sizes.end(),
+                    d_row_sizes.begin(),
+                    cuda::proclaim_return_type<size_type>(
+                      [fixed_width_and_validity_size] __device__(auto row_size) {
+                        return util::round_up_unsafe(fixed_width_and_validity_size + row_size,
+                                                     JCUDF_ROW_ALIGNMENT);
+                      }));
+
+  return {std::move(d_row_sizes), std::move(d_offsets_iterators)};
+}
+
+/**
+ * @brief functor to return the offset of a row in a table with string columns
+ *
+ */
+struct string_row_offset_functor {
+  string_row_offset_functor(device_span<size_type const> d_row_offsets)
+    : d_row_offsets(d_row_offsets){};
+
+  __device__ inline size_type operator()(int row_number, int) const
+  {
+    return d_row_offsets[row_number];
+  }
+
+  device_span<size_type const> d_row_offsets;
+};
+
+/**
+ * @brief functor to return the offset of a row in a table with only fixed-width columns
+ *
+ */
+struct fixed_width_row_offset_functor {
+  fixed_width_row_offset_functor(size_type fixed_width_only_row_size)
+    : _fixed_width_only_row_size(fixed_width_only_row_size){};
+
+  __device__ inline size_type operator()(int row_number, int tile_row_start) const
+  {
+    return (row_number - tile_row_start) * _fixed_width_only_row_size;
+  }
+
+  size_type _fixed_width_only_row_size;
+};
+
+/**
+ * @brief Copies data from row-based JCUDF format to column-based cudf format.
+ *
+ * This optimized version of the conversion is faster for fixed-width tables that do not have more
+ * than 100 columns.
+ *
+ * @param num_rows number of rows in the incoming table
+ * @param num_columns number of columns in the incoming table
+ * @param row_size length in bytes of each row
+ * @param input_offset_in_row offset to each row of data
+ * @param num_bytes total number of bytes in the incoming data
+ * @param output_data array of pointers to the output data
+ * @param output_nm array of pointers to the output null masks
+ * @param input_data pointing to the incoming row data
+ */
+CUDF_KERNEL void copy_from_rows_fixed_width_optimized(const size_type num_rows,
+                                                      const size_type num_columns,
+                                                      const size_type row_size,
+                                                      const size_type* input_offset_in_row,
+                                                      const size_type* num_bytes,
+                                                      int8_t** output_data,
+                                                      bitmask_type** output_nm,
+                                                      const int8_t* input_data)
+{
+  // We are going to copy the data in two passes.
+  // The first pass copies a chunk of data into shared memory.
+  // The second pass copies that chunk from shared memory out to the final location.
+
+  // Because shared memory is limited we copy a subset of the rows at a time.
+  // For simplicity we will refer to this as a row_group
+
+  // In practice we have found writing more than 4 columns of data per thread
+  // results in performance loss. As such we are using a 2 dimensional
+  // kernel in terms of threads, but not in terms of blocks. Columns are
+  // controlled by the y dimension (there is no y dimension in blocks). Rows
+  // are controlled by the x dimension (there are multiple blocks in the x
+  // dimension).
+
+  size_type const rows_per_group   = blockDim.x;
+  size_type const row_group_start  = blockIdx.x;
+  size_type const row_group_stride = gridDim.x;
+  size_type const row_group_end    = (num_rows + rows_per_group - 1) / rows_per_group + 1;
+
+  extern __shared__ int8_t shared_data[];
+
+  // Because we are copying fixed width only data and we stride the rows
+  // this thread will always start copying from shared data in the same place
+  int8_t* row_tmp     = &shared_data[row_size * threadIdx.x];
+  int8_t* row_vld_tmp = &row_tmp[input_offset_in_row[num_columns - 1] + num_bytes[num_columns - 1]];
+
+  for (auto row_group_index = row_group_start; row_group_index < row_group_end;
+       row_group_index += row_group_stride) {
+    // Step 1: Copy the data into shared memory
+    // We know row_size is always aligned with and a multiple of int64_t;
+    int64_t* long_shared      = reinterpret_cast<int64_t*>(shared_data);
+    int64_t const* long_input = reinterpret_cast<int64_t const*>(input_data);
+
+    auto const shared_output_index  = threadIdx.x + (threadIdx.y * blockDim.x);
+    auto const shared_output_stride = blockDim.x * blockDim.y;
+    auto const row_index_end        = std::min(num_rows, ((row_group_index + 1) * rows_per_group));
+    auto const num_rows_in_group    = row_index_end - (row_group_index * rows_per_group);
+    auto const shared_length        = row_size * num_rows_in_group;
+
+    size_type const shared_output_end = shared_length / sizeof(int64_t);
+
+    auto const start_input_index = (row_size * row_group_index * rows_per_group) / sizeof(int64_t);
+
+    for (size_type shared_index = shared_output_index; shared_index < shared_output_end;
+         shared_index += shared_output_stride) {
+      long_shared[shared_index] = long_input[start_input_index + shared_index];
+    }
+    // Wait for all of the data to be in shared memory
+    __syncthreads();
+
+    // Step 2 copy the data back out
+
+    // Within the row group there should be 1 thread for each row.  This is a
+    // requirement for launching the kernel
+    auto const row_index = (row_group_index * rows_per_group) + threadIdx.x;
+    // But we might not use all of the threads if the number of rows does not go
+    // evenly into the thread count. We don't want those threads to exit yet
+    // because we may need them to copy data in for the next row group.
+    uint32_t active_mask = __ballot_sync(0xffffffff, row_index < num_rows);
+    if (row_index < num_rows) {
+      auto const col_index_start  = threadIdx.y;
+      auto const col_index_stride = blockDim.y;
+      for (auto col_index = col_index_start; col_index < num_columns;
+           col_index += col_index_stride) {
+        auto const col_size   = num_bytes[col_index];
+        int8_t const* col_tmp = &(row_tmp[input_offset_in_row[col_index]]);
+        int8_t* col_output    = output_data[col_index];
+        switch (col_size) {
+          case 1: {
+            col_output[row_index] = *col_tmp;
+            break;
+          }
+          case 2: {
+            int16_t* short_col_output   = reinterpret_cast<int16_t*>(col_output);
+            short_col_output[row_index] = *reinterpret_cast<const int16_t*>(col_tmp);
+            break;
+          }
+          case 4: {
+            int32_t* int_col_output   = reinterpret_cast<int32_t*>(col_output);
+            int_col_output[row_index] = *reinterpret_cast<const int32_t*>(col_tmp);
+            break;
+          }
+          case 8: {
+            int64_t* long_col_output   = reinterpret_cast<int64_t*>(col_output);
+            long_col_output[row_index] = *reinterpret_cast<const int64_t*>(col_tmp);
+            break;
+          }
+          default: {
+            auto const output_offset = col_size * row_index;
+            // TODO this should just not be supported for fixed width columns, but just in case...
+            for (auto b = 0; b < col_size; b++) {
+              col_output[b + output_offset] = col_tmp[b];
+            }
+            break;
+          }
+        }
+
+        bitmask_type* nm          = output_nm[col_index];
+        int8_t* valid_byte        = &row_vld_tmp[col_index / 8];
+        size_type byte_bit_offset = col_index % 8;
+        int predicate             = *valid_byte & (1 << byte_bit_offset);
+        uint32_t bitmask          = __ballot_sync(active_mask, predicate);
+        if (row_index % 32 == 0) { nm[word_index(row_index)] = bitmask; }
+      }  // end column loop
+    }    // end row copy
+    // wait for the row_group to be totally copied before starting on the next row group
+    __syncthreads();
+  }
+}
+
+CUDF_KERNEL void copy_to_rows_fixed_width_optimized(const size_type start_row,
+                                                    const size_type num_rows,
+                                                    const size_type num_columns,
+                                                    const size_type row_size,
+                                                    const size_type* output_offset_in_row,
+                                                    const size_type* num_bytes,
+                                                    const int8_t** input_data,
+                                                    const bitmask_type** input_nm,
+                                                    int8_t* output_data)
+{
+  // We are going to copy the data in two passes.
+  // The first pass copies a chunk of data into shared memory.
+  // The second pass copies that chunk from shared memory out to the final location.
+
+  // Because shared memory is limited we copy a subset of the rows at a time.
+  // We do not support copying a subset of the columns in a row yet, so we don't
+  // currently support a row that is wider than shared memory.
+  // For simplicity we will refer to this as a row_group
+
+  // In practice we have found reading more than 4 columns of data per thread
+  // results in performance loss. As such we are using a 2 dimensional
+  // kernel in terms of threads, but not in terms of blocks. Columns are
+  // controlled by the y dimension (there is no y dimension in blocks). Rows
+  // are controlled by the x dimension (there are multiple blocks in the x
+  // dimension).
+
+  size_type rows_per_group   = blockDim.x;
+  size_type row_group_start  = blockIdx.x;
+  size_type row_group_stride = gridDim.x;
+  size_type row_group_end    = (num_rows + rows_per_group - 1) / rows_per_group + 1;
+
+  extern __shared__ int8_t shared_data[];
+
+  // Because we are copying fixed width only data and we stride the rows
+  // this thread will always start copying to shared data in the same place
+  int8_t* row_tmp = &shared_data[row_size * threadIdx.x];
+  int8_t* row_vld_tmp =
+    &row_tmp[output_offset_in_row[num_columns - 1] + num_bytes[num_columns - 1]];
+
+  for (size_type row_group_index = row_group_start; row_group_index < row_group_end;
+       row_group_index += row_group_stride) {
+    // Within the row group there should be 1 thread for each row.  This is a
+    // requirement for launching the kernel
+    size_type row_index = start_row + (row_group_index * rows_per_group) + threadIdx.x;
+    // But we might not use all of the threads if the number of rows does not go
+    // evenly into the thread count. We don't want those threads to exit yet
+    // because we may need them to copy data back out.
+    if (row_index < (start_row + num_rows)) {
+      size_type col_index_start  = threadIdx.y;
+      size_type col_index_stride = blockDim.y;
+      for (size_type col_index = col_index_start; col_index < num_columns;
+           col_index += col_index_stride) {
+        size_type col_size      = num_bytes[col_index];
+        int8_t* col_tmp         = &(row_tmp[output_offset_in_row[col_index]]);
+        const int8_t* col_input = input_data[col_index];
+        switch (col_size) {
+          case 1: {
+            *col_tmp = col_input[row_index];
+            break;
+          }
+          case 2: {
+            const int16_t* short_col_input       = reinterpret_cast<const int16_t*>(col_input);
+            *reinterpret_cast<int16_t*>(col_tmp) = short_col_input[row_index];
+            break;
+          }
+          case 4: {
+            const int32_t* int_col_input         = reinterpret_cast<const int32_t*>(col_input);
+            *reinterpret_cast<int32_t*>(col_tmp) = int_col_input[row_index];
+            break;
+          }
+          case 8: {
+            const int64_t* long_col_input        = reinterpret_cast<const int64_t*>(col_input);
+            *reinterpret_cast<int64_t*>(col_tmp) = long_col_input[row_index];
+            break;
+          }
+          default: {
+            size_type input_offset = col_size * row_index;
+            // TODO this should just not be supported for fixed width columns, but just in case...
+            for (size_type b = 0; b < col_size; b++) {
+              col_tmp[b] = col_input[b + input_offset];
+            }
+            break;
+          }
+        }
+        // atomicOr only works on 32 bit or 64 bit  aligned values, and not byte aligned
+        // so we have to rewrite the addresses to make sure that it is 4 byte aligned
+        int8_t* valid_byte        = &row_vld_tmp[col_index / 8];
+        size_type byte_bit_offset = col_index % 8;
+        uint64_t fixup_bytes      = reinterpret_cast<uint64_t>(valid_byte) % 4;
+        int32_t* valid_int        = reinterpret_cast<int32_t*>(valid_byte - fixup_bytes);
+        size_type int_bit_offset  = byte_bit_offset + (fixup_bytes * 8);
+        // Now copy validity for the column
+        if (input_nm[col_index]) {
+          if (bit_is_set(input_nm[col_index], row_index)) {
+            atomicOr_block(valid_int, 1 << int_bit_offset);
+          } else {
+            atomicAnd_block(valid_int, ~(1 << int_bit_offset));
+          }
+        } else {
+          // It is valid so just set the bit
+          atomicOr_block(valid_int, 1 << int_bit_offset);
+        }
+      }  // end column loop
+    }    // end row copy
+    // wait for the row_group to be totally copied into shared memory
+    __syncthreads();
+
+    // Step 2: Copy the data back out
+    // We know row_size is always aligned with and a multiple of int64_t;
+    int64_t* long_shared = reinterpret_cast<int64_t*>(shared_data);
+    int64_t* long_output = reinterpret_cast<int64_t*>(output_data);
+
+    size_type shared_input_index  = threadIdx.x + (threadIdx.y * blockDim.x);
+    size_type shared_input_stride = blockDim.x * blockDim.y;
+    size_type row_index_end       = ((row_group_index + 1) * rows_per_group);
+    if (row_index_end > num_rows) { row_index_end = num_rows; }
+    size_type num_rows_in_group = row_index_end - (row_group_index * rows_per_group);
+    size_type shared_length     = row_size * num_rows_in_group;
+
+    size_type shared_input_end = shared_length / sizeof(int64_t);
+
+    size_type start_output_index = (row_size * row_group_index * rows_per_group) / sizeof(int64_t);
+
+    for (size_type shared_index = shared_input_index; shared_index < shared_input_end;
+         shared_index += shared_input_stride) {
+      long_output[start_output_index + shared_index] = long_shared[shared_index];
+    }
+    __syncthreads();
+    // Go for the next round
+  }
+}
+
+/**
+ * @brief copy data from cudf columns into JCUDF format, which is row-based
+ *
+ * @tparam RowOffsetFunctor iterator that gives the size of a specific row of the table.
+ * @param num_rows total number of rows in the table
+ * @param num_columns total number of columns in the table
+ * @param shmem_used_per_tile shared memory amount each `tile_info` is using
+ * @param tile_infos span of `tile_info` structs the define the work
+ * @param input_data pointer to raw table data
+ * @param col_sizes array of sizes for each element in a column - one per column
+ * @param col_offsets offset into input data row for each column's start
+ * @param row_offsets offset to a specific row in the output data
+ * @param batch_row_boundaries row numbers for batch starts
+ * @param output_data pointer to output data
+ *
+ */
+template <typename RowOffsetFunctor>
+CUDF_KERNEL void copy_to_rows(const size_type num_rows,
+                              const size_type num_columns,
+                              const size_type shmem_used_per_tile,
+                              device_span<const tile_info> tile_infos,
+                              const int8_t** input_data,
+                              const size_type* col_sizes,
+                              const size_type* col_offsets,
+                              RowOffsetFunctor row_offsets,
+                              size_type const* batch_row_boundaries,
+                              int8_t** output_data)
+{
+  // We are going to copy the data in two passes.
+  // The first pass copies a chunk of data into shared memory.
+  // The second pass copies that chunk from shared memory out to the final location.
+
+  // Because shared memory is limited we copy a subset of the rows at a time.
+  // This has been broken up for us in the tile_info struct, so we don't have
+  // any calculation to do here, but it is important to note.
+
+  auto const group = cooperative_groups::this_thread_block();
+  auto const warp  = cooperative_groups::tiled_partition<cudf::detail::warp_size>(group);
+  extern __shared__ int8_t shared_data[];
+
+  __shared__ cuda::barrier<cuda::thread_scope_block> tile_barrier;
+  if (group.thread_rank() == 0) { init(&tile_barrier, group.size()); }
+  group.sync();
+
+  auto const tile                   = tile_infos[blockIdx.x];
+  auto const num_tile_cols          = tile.num_cols();
+  auto const num_tile_rows          = tile.num_rows();
+  auto const tile_row_size          = tile.get_shared_row_size(col_offsets, col_sizes);
+  auto const starting_column_offset = col_offsets[tile.start_col];
+
+  // to do the copy we need to do n column copies followed by m element copies OR we have to do m
+  // element copies followed by r row copies. When going from column to row it is much easier to
+  // copy by elements first otherwise we would need a running total of the column sizes for our
+  // tile, which isn't readily available. This makes it more appealing to copy element-wise from
+  // input data into shared matching the end layout and do row-based memcopies out.
+
+  // read each column across the tile
+  // each warp takes a column with each thread of a warp taking a row this is done with cooperative
+  // groups where each column is chosen by the tiled partition and each thread in that partition
+  // works on a row
+  for (int relative_col = warp.meta_group_rank(); relative_col < num_tile_cols;
+       relative_col += warp.meta_group_size()) {
+    auto const absolute_col        = relative_col + tile.start_col;
+    auto const col_size            = col_sizes[absolute_col];
+    auto const col_offset          = col_offsets[absolute_col];
+    auto const relative_col_offset = col_offset - starting_column_offset;
+    auto const col_ptr             = input_data[absolute_col];
+
+    if (col_ptr == nullptr) {
+      // variable-width data column
+      continue;
+    }
+
+    for (int relative_row = warp.thread_rank(); relative_row < num_tile_rows;
+         relative_row += warp.size()) {
+      if (relative_row >= num_tile_rows) {
+        // out of bounds
+        continue;
+      }
+      auto const absolute_row = relative_row + tile.start_row;
+
+      auto const shared_offset = relative_row * tile_row_size + relative_col_offset;
+      auto const input_src     = col_ptr + col_size * absolute_row;
+
+      // copy the element from global memory
+      switch (col_size) {
+        case 2: {
+          const int16_t* short_col_input = reinterpret_cast<const int16_t*>(input_src);
+          *reinterpret_cast<int16_t*>(&shared_data[shared_offset]) = *short_col_input;
+          break;
+        }
+        case 4: {
+          const int32_t* int_col_input = reinterpret_cast<const int32_t*>(input_src);
+          *reinterpret_cast<int32_t*>(&shared_data[shared_offset]) = *int_col_input;
+          break;
+        }
+        case 8: {
+          const int64_t* long_col_input = reinterpret_cast<const int64_t*>(input_src);
+          *reinterpret_cast<int64_t*>(&shared_data[shared_offset]) = *long_col_input;
+          break;
+        }
+        case 1: shared_data[shared_offset] = *input_src; break;
+        default: {
+          for (int i = 0; i < col_size; ++i) {
+            shared_data[shared_offset] = *input_src;
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  auto const tile_output_buffer = output_data[tile.batch_number];
+  auto const row_batch_start = tile.batch_number == 0 ? 0 : batch_row_boundaries[tile.batch_number];
+
+  // no async copies above waiting on the barrier, so we sync the group here to ensure all copies to
+  // shared memory are completed before copying data out
+  group.sync();
+
+  // each warp takes a row
+  for (int copy_row = warp.meta_group_rank(); copy_row < tile.num_rows();
+       copy_row += warp.meta_group_size()) {
+    auto const src = &shared_data[tile_row_size * copy_row];
+    auto const dst = tile_output_buffer + row_offsets(copy_row + tile.start_row, row_batch_start) +
+                     starting_column_offset;
+    cuda::memcpy_async(warp, dst, src, tile_row_size, tile_barrier);
+  }
+
+  // wait on the last copies to complete
+  tile_barrier.arrive_and_wait();
+}
+
+/**
+ * @brief copy data from row-based format to cudf columns
+ *
+ * @tparam RowOffsetFunctor iterator that gives the size of a specific row of the table.
+ * @param num_rows total number of rows in the table
+ * @param num_columns total number of columns in the table
+ * @param shmem_used_per_tile amount of shared memory that is used by a tile
+ * @param row_offsets offset to a specific row in the output data
+ * @param batch_row_boundaries row numbers for batch starts
+ * @param output_data pointer to output data, partitioned by data size
+ * @param validity_offsets offset into input data row for validity data
+ * @param tile_infos information about the tiles of work
+ * @param input_nm pointer to input data
+ *
+ */
+template <typename RowOffsetFunctor>
+CUDF_KERNEL void copy_validity_to_rows(const size_type num_rows,
+                                       const size_type num_columns,
+                                       const size_type shmem_used_per_tile,
+                                       RowOffsetFunctor row_offsets,
+                                       size_type const* batch_row_boundaries,
+                                       int8_t** output_data,
+                                       const size_type validity_offset,
+                                       device_span<const tile_info> tile_infos,
+                                       const bitmask_type** input_nm)
+{
+  extern __shared__ int8_t shared_data[];
+
+  // each thread of warp reads a single int32 of validity - so we read 128 bytes then ballot_sync
+  // the bits and write the result to shmem after we fill shared mem memcpy it out in a blob.
+  auto const group = cooperative_groups::this_thread_block();
+  auto const warp  = cooperative_groups::tiled_partition<cudf::detail::warp_size>(group);
+
+  // Initialize cuda barriers for each tile.
+  __shared__ cuda::barrier<cuda::thread_scope_block> shared_tile_barrier;
+  if (group.thread_rank() == 0) { init(&shared_tile_barrier, group.size()); }
+  group.sync();
+
+  auto tile                = tile_infos[blockIdx.x];
+  auto const num_tile_cols = tile.num_cols();
+  auto const num_tile_rows = tile.num_rows();
+
+  auto const threads_per_warp = warp.size();
+  auto const rows_per_read    = cudf::detail::size_in_bits<bitmask_type>();
+
+  auto const num_sections_x = util::div_rounding_up_unsafe(num_tile_cols, threads_per_warp);
+  auto const num_sections_y = util::div_rounding_up_unsafe(num_tile_rows, rows_per_read);
+  auto const validity_data_row_length = util::round_up_unsafe(
+    util::div_rounding_up_unsafe(num_tile_cols, CHAR_BIT), JCUDF_ROW_ALIGNMENT);
+  auto const total_sections = num_sections_x * num_sections_y;
+
+  // the tile is divided into sections. A warp operates on a section at a time.
+  for (int my_section_idx = warp.meta_group_rank(); my_section_idx < total_sections;
+       my_section_idx += warp.meta_group_size()) {
+    // convert to rows and cols
+    auto const section_x          = my_section_idx % num_sections_x;
+    auto const section_y          = my_section_idx / num_sections_x;
+    auto const relative_col       = section_x * threads_per_warp + warp.thread_rank();
+    auto const relative_row       = section_y * rows_per_read;
+    auto const absolute_col       = relative_col + tile.start_col;
+    auto const absolute_row       = relative_row + tile.start_row;
+    auto const participating      = absolute_col < num_columns && absolute_row < num_rows;
+    auto const participation_mask = __ballot_sync(0xFFFFFFFF, participating);
+
+    if (participating) {
+      auto my_data = input_nm[absolute_col] != nullptr
+                       ? input_nm[absolute_col][word_index(absolute_row)]
+                       : std::numeric_limits<uint32_t>::max();
+
+      // every thread that is participating in the warp has 4 bytes, but it's column-based data and
+      // we need it in row-based. So we shuffle the bits around with ballot_sync to make the bytes
+      // we actually write.
+      bitmask_type dw_mask = 0x1;
+      for (int i = 0; i < threads_per_warp && relative_row + i < num_rows; ++i, dw_mask <<= 1) {
+        auto validity_data = __ballot_sync(participation_mask, my_data & dw_mask);
+        // lead thread in each warp writes data
+        auto const validity_write_offset =
+          validity_data_row_length * (relative_row + i) + (relative_col / CHAR_BIT);
+        if (warp.thread_rank() == 0) {
+          *reinterpret_cast<bitmask_type*>(&shared_data[validity_write_offset]) = validity_data;
+        }
+      }
+    }
+  }
+
+  auto const output_data_base =
+    output_data[tile.batch_number] + validity_offset + tile.start_col / CHAR_BIT;
+
+  // each warp copies a row at a time
+  auto const row_bytes       = util::div_rounding_up_unsafe(num_tile_cols, CHAR_BIT);
+  auto const row_batch_start = tile.batch_number == 0 ? 0 : batch_row_boundaries[tile.batch_number];
+
+  // make sure entire tile has finished copy
+  // Note that this was copied from above just under the for loop due to nsight complaints about
+  // divergent threads
+  group.sync();
+
+  for (int relative_row = warp.meta_group_rank(); relative_row < num_tile_rows;
+       relative_row += warp.meta_group_size()) {
+    auto const src = &shared_data[validity_data_row_length * relative_row];
+    auto const dst = output_data_base + row_offsets(relative_row + tile.start_row, row_batch_start);
+    cuda::memcpy_async(warp, dst, src, row_bytes, shared_tile_barrier);
+  }
+
+  // wait for tile of data to arrive
+  shared_tile_barrier.arrive_and_wait();
+}
+
+/**
+ * @brief kernel to copy string data to JCUDF row format
+ *
+ * @tparam RowOffsetFunctor iterator for row offsets into the destination data
+ * @param num_rows number of rows in this portion of the table
+ * @param num_variable_columns number of columns of variable-width data
+ * @param variable_input_data variable width data column pointers
+ * @param variable_col_output_offsets output offset information for variable-width columns
+ * @param variable_col_offsets input offset information for variable-width columns
+ * @param fixed_width_row_size offset to variable-width data in a row
+ * @param row_offsets offsets for each row in output data
+ * @param batch_row_offset row start for this batch
+ * @param output_data pointer to output data for this batch
+ *
+ */
+template <typename RowOffsetFunctor>
+CUDF_KERNEL void copy_strings_to_rows(size_type const num_rows,
+                                      size_type const num_variable_columns,
+                                      int8_t const** variable_input_data,
+                                      size_type const* variable_col_output_offsets,
+                                      cudf::detail::input_offsetalator* variable_col_offsets,
+                                      size_type fixed_width_row_size,
+                                      RowOffsetFunctor row_offsets,
+                                      size_type const batch_row_offset,
+                                      int8_t* output_data)
+{
+  // Each block will take a group of rows controlled by NUM_STRING_ROWS_PER_BLOCK_TO_ROWS. Each warp
+  // will copy a row at a time. The base thread will first go through column data and fill out
+  // offset/length information for the column. Then all threads of the warp will participate in the
+  // memcpy of the string data.
+  auto const my_block = cooperative_groups::this_thread_block();
+  auto const warp     = cooperative_groups::tiled_partition<cudf::detail::warp_size>(my_block);
+  cuda::barrier<cuda::thread_scope_block> block_barrier;
+
+  auto const start_row =
+    blockIdx.x * NUM_STRING_ROWS_PER_BLOCK_TO_ROWS + warp.meta_group_rank() + batch_row_offset;
+  auto const end_row =
+    std::min(num_rows, static_cast<size_type>(start_row + NUM_STRING_ROWS_PER_BLOCK_TO_ROWS));
+
+  for (int row = start_row; row < end_row; row += warp.meta_group_size()) {
+    auto offset                = fixed_width_row_size;  // initial offset to variable-width data
+    auto const base_row_offset = row_offsets(row, 0);
+    for (int col = 0; col < num_variable_columns; ++col) {
+      auto const string_start_offset = variable_col_offsets[col][row];
+      auto const string_length       = variable_col_offsets[col][row + 1] - string_start_offset;
+      if (warp.thread_rank() == 0) {
+        // write the offset/length to column
+        uint32_t* output_dest = reinterpret_cast<uint32_t*>(
+          &output_data[base_row_offset + variable_col_output_offsets[col]]);
+        output_dest[0] = offset;
+        output_dest[1] = string_length;
+      }
+      auto string_output_dest = &output_data[base_row_offset + offset];
+      auto string_output_src  = &variable_input_data[col][string_start_offset];
+      warp.sync();
+      cuda::memcpy_async(warp, string_output_dest, string_output_src, string_length, block_barrier);
+      offset += string_length;
+    }
+  }
+}
+/**
+ * @brief copy data from row-based format to cudf columns
+ *
+ * @tparam RowOffsetFunctor iterator that gives the size of a specific row of the table.
+ * @param num_rows total number of rows in the table
+ * @param num_columns total number of columns in the table
+ * @param shmem_used_per_tile amount of shared memory that is used by a tile
+ * @param row_offsets offset to a specific row in the input data
+ * @param batch_row_boundaries row numbers for batch starts
+ * @param output_data pointers to column data
+ * @param col_sizes array of sizes for each element in a column - one per column
+ * @param col_offsets offset into input data row for each column's start
+ * @param tile_infos information about the tiles of work
+ * @param input_data pointer to input data
+ *
+ */
+template <typename RowOffsetFunctor>
+CUDF_KERNEL void copy_from_rows(const size_type num_rows,
+                                const size_type num_columns,
+                                const size_type shmem_used_per_tile,
+                                RowOffsetFunctor row_offsets,
+                                size_type const* batch_row_boundaries,
+                                int8_t** output_data,
+                                const size_type* col_sizes,
+                                const size_type* col_offsets,
+                                device_span<const tile_info> tile_infos,
+                                const int8_t* input_data)
+{
+  // We are going to copy the data in two passes.
+  // The first pass copies a chunk of data into shared memory.
+  // The second pass copies that chunk from shared memory out to the final location.
+
+  // Because shared memory is limited we copy a subset of the rows at a time. This has been broken
+  // up for us in the tile_info struct, so we don't have any calculation to do here, but it is
+  // important to note.
+
+  // To speed up some of the random access memory we do, we copy col_sizes and col_offsets to shared
+  // memory for each of the tiles that we work on
+
+  auto const group = cooperative_groups::this_thread_block();
+  auto const warp  = cooperative_groups::tiled_partition<cudf::detail::warp_size>(group);
+  extern __shared__ int8_t shared[];
+
+  // Initialize cuda barriers for each tile.
+  __shared__ cuda::barrier<cuda::thread_scope_block> tile_barrier;
+  if (group.thread_rank() == 0) { init(&tile_barrier, group.size()); }
+  group.sync();
+
+  {
+    auto const fetch_tile           = tile_infos[blockIdx.x];
+    auto const fetch_tile_start_row = fetch_tile.start_row;
+    auto const starting_col_offset  = col_offsets[fetch_tile.start_col];
+    auto const fetch_tile_row_size  = fetch_tile.get_shared_row_size(col_offsets, col_sizes);
+    auto const row_batch_start =
+      fetch_tile.batch_number == 0 ? 0 : batch_row_boundaries[fetch_tile.batch_number];
+
+    for (int absolute_row = warp.meta_group_rank() + fetch_tile.start_row;
+         absolute_row <= fetch_tile.end_row;
+         absolute_row += warp.meta_group_size()) {
+      warp.sync();
+      auto shared_offset = (absolute_row - fetch_tile_start_row) * fetch_tile_row_size;
+      auto dst           = &shared[shared_offset];
+      auto src = &input_data[row_offsets(absolute_row, row_batch_start) + starting_col_offset];
+      // copy the data
+      cuda::memcpy_async(warp, dst, src, fetch_tile_row_size, tile_barrier);
+    }
+  }
+
+  {
+    auto const tile          = tile_infos[blockIdx.x];
+    auto const rows_in_tile  = tile.num_rows();
+    auto const cols_in_tile  = tile.num_cols();
+    auto const tile_row_size = tile.get_shared_row_size(col_offsets, col_sizes);
+
+    // ensure our data is ready
+    tile_barrier.arrive_and_wait();
+
+    // Now we copy from shared memory to final destination. The data is laid out in rows in shared
+    // memory, so the reads for a column will be "vertical". Because of this and the different sizes
+    // for each column, this portion is handled on row/column basis. to prevent each thread working
+    // on a single row and also to ensure that all threads can do work in the case of more threads
+    // than rows, we do a global index instead of a double for loop with col/row.
+    for (int relative_row = warp.thread_rank(); relative_row < rows_in_tile;
+         relative_row += warp.size()) {
+      auto const absolute_row             = relative_row + tile.start_row;
+      auto const shared_memory_row_offset = tile_row_size * relative_row;
+
+      for (int relative_col = warp.meta_group_rank(); relative_col < cols_in_tile;
+           relative_col += warp.meta_group_size()) {
+        auto const absolute_col = relative_col + tile.start_col;
+
+        auto const shared_memory_offset =
+          col_offsets[absolute_col] - col_offsets[tile.start_col] + shared_memory_row_offset;
+        auto const column_size = col_sizes[absolute_col];
+
+        int8_t* shmem_src = &shared[shared_memory_offset];
+        int8_t* dst       = &output_data[absolute_col][absolute_row * column_size];
+
+        cuda::memcpy_async(dst, shmem_src, column_size, tile_barrier);
+      }
+    }
+  }
+
+  // wait on the last copies to complete
+  tile_barrier.arrive_and_wait();
+}
+
+/**
+ * @brief copy data from row-based format to cudf columns
+ *
+ * @tparam RowOffsetFunctor iterator that gives the size of a specific row of the table.
+ * @param num_rows total number of rows in the table
+ * @param num_columns total number of columns in the table
+ * @param shmem_used_per_tile amount of shared memory that is used by a tile
+ * @param row_offsets offset to the first column a specific row in the input data
+ * @param batch_row_boundaries row numbers for batch starts
+ * @param output_nm pointers to null masks for columns
+ * @param validity_offsets offset into input data row for validity data
+ * @param tile_infos information about the tiles of work
+ * @param input_data pointer to input data
+ *
+ */
+template <typename RowOffsetFunctor>
+CUDF_KERNEL void copy_validity_from_rows(const size_type num_rows,
+                                         const size_type num_columns,
+                                         const size_type shmem_used_per_tile,
+                                         RowOffsetFunctor row_offsets,
+                                         size_type const* batch_row_boundaries,
+                                         bitmask_type** output_nm,
+                                         const size_type validity_offset,
+                                         device_span<const tile_info> tile_infos,
+                                         const int8_t* input_data)
+{
+  extern __shared__ int8_t shared[];
+
+  using cudf::detail::warp_size;
+
+  // each thread of warp reads a single byte of validity - so we read 32 bytes then ballot_sync the
+  // bits and write the result to shmem after we fill shared mem memcpy it out in a blob. Probably
+  // need knobs for number of rows vs columns to balance read/write
+
+  //        C0  C1  C2  C3  C4  C5  C6  C7
+  //  R0    1   0   1   0   0   1   1   0       <-- thread 0 reads byte r0
+  //  R1    1   1   1   1   1   1   1   0       <-- thread 1 reads byte r1
+  //  R2    0   0   1   0   0   1   1   0       <-- thread 2 reads byte r2
+  //  ...
+  //  R31   1   1   1   1   1   1   1   1       <-- thread 31 reads byte r31
+  //        ^
+  //        |  1 bit of each input byte, by column, are swizzled into a single 32 bit word via
+  //        __ballot_sync, representing 32 rows of that column.
+
+  auto const group = cooperative_groups::this_thread_block();
+  auto const warp  = cooperative_groups::tiled_partition<cudf::detail::warp_size>(group);
+
+  // Initialize cuda barriers for each tile.
+  __shared__ cuda::barrier<cuda::thread_scope_block> shared_tile_barrier;
+  if (group.thread_rank() == 0) { init(&shared_tile_barrier, group.size()); }
+  group.sync();
+
+  auto const tile           = tile_infos[blockIdx.x];
+  auto const tile_start_col = tile.start_col;
+  auto const tile_start_row = tile.start_row;
+  auto const num_tile_cols  = tile.num_cols();
+  auto const num_tile_rows  = tile.num_rows();
+
+  auto const threads_per_warp = warp.size();
+  auto const cols_per_read    = CHAR_BIT;
+
+  auto const rows_per_read            = static_cast<size_type>(threads_per_warp);
+  auto const num_sections_x           = util::div_rounding_up_safe(num_tile_cols, cols_per_read);
+  auto const num_sections_y           = util::div_rounding_up_safe(num_tile_rows, rows_per_read);
+  auto const validity_data_col_length = num_sections_y * 4;  // words to bytes
+  auto const total_sections           = num_sections_x * num_sections_y;
+
+  // the tile is divided into sections. A warp operates on a section at a time.
+  for (int my_section_idx = warp.meta_group_rank(); my_section_idx < total_sections;
+       my_section_idx += warp.meta_group_size()) {
+    // convert section to row and col
+    auto const section_x    = my_section_idx % num_sections_x;
+    auto const section_y    = my_section_idx / num_sections_x;
+    auto const relative_col = section_x * cols_per_read;
+    auto const relative_row = section_y * rows_per_read + warp.thread_rank();
+    auto const absolute_col = relative_col + tile_start_col;
+    auto const absolute_row = relative_row + tile_start_row;
+    auto const row_batch_start =
+      tile.batch_number == 0 ? 0 : batch_row_boundaries[tile.batch_number];
+
+    auto const participation_mask = __ballot_sync(0xFFFFFFFF, absolute_row < num_rows);
+
+    if (absolute_row < num_rows) {
+      auto const my_byte = input_data[row_offsets(absolute_row, row_batch_start) + validity_offset +
+                                      (absolute_col / cols_per_read)];
+
+      // so every thread that is participating in the warp has a byte, but it's row-based data and
+      // we need it in column-based. So we shuffle the bits around to make the bytes we actually
+      // write.
+      for (int i = 0, byte_mask = 0x1; (i < cols_per_read) && ((relative_col + i) < num_columns);
+           ++i, byte_mask <<= 1) {
+        auto const validity_data = __ballot_sync(participation_mask, my_byte & byte_mask);
+        // lead thread in each warp writes data
+        if (warp.thread_rank() == 0) {
+          auto const validity_write_offset =
+            validity_data_col_length * (relative_col + i) + relative_row / cols_per_read;
+          *reinterpret_cast<bitmask_type*>(&shared[validity_write_offset]) = validity_data;
+        }
+      }
+    }
+  }
+
+  // now memcpy the shared memory out to the final destination
+  auto const col_words = util::div_rounding_up_unsafe(num_tile_rows, CHAR_BIT * 4);
+
+  // make sure entire tile has finished copy
+  group.sync();
+
+  for (int relative_col = warp.meta_group_rank(); relative_col < num_tile_cols;
+       relative_col += warp.meta_group_size()) {
+    auto const absolute_col = relative_col + tile_start_col;
+    auto dst                = output_nm[absolute_col] + word_index(tile_start_row);
+    auto const src =
+      reinterpret_cast<bitmask_type*>(&shared[validity_data_col_length * relative_col]);
+
+    cuda::memcpy_async(
+      warp, dst, src, cuda::aligned_size_t<4>(validity_data_col_length), shared_tile_barrier);
+  }
+
+  // wait for tile of data to arrive
+  shared_tile_barrier.arrive_and_wait();
+}
+
+/**
+ * @brief copies string data from jcudf row format to cudf columns
+ *
+ * @tparam RowOffsetFunctor iterator for row offsets into the destination data
+ * @param row_offsets offsets for each row in input data
+ * @param string_row_offsets offset data into jcudf row data for each string
+ * @param string_lengths length of each incoming string in each column
+ * @param string_column_offsets offset column data for cudf column
+ * @param string_col_data output cudf string column data
+ * @param row_data jcudf row data
+ * @param num_rows number of rows in data
+ * @param num_string_columns number of string columns in the table
+ */
+template <typename RowOffsetFunctor>
+CUDF_KERNEL void copy_strings_from_rows(RowOffsetFunctor row_offsets,
+                                        int32_t** string_row_offsets,
+                                        int32_t** string_lengths,
+                                        size_type** string_column_offsets,
+                                        char** string_col_data,
+                                        int8_t const* row_data,
+                                        size_type const num_rows,
+                                        size_type const num_string_columns)
+{
+  // Each warp takes a tile, which is a single column and up to ROWS_PER_BLOCK rows. A tile will not
+  // wrap around the bottom of the table. The warp will copy the strings for each row in the tile.
+  // Traversing in row-major order to coalesce the offsets and size reads.
+  auto my_block = cooperative_groups::this_thread_block();
+  auto warp     = cooperative_groups::tiled_partition<cudf::detail::warp_size>(my_block);
+  cuda::barrier<cuda::thread_scope_block> block_barrier;
+
+  // workaround for not being able to take a reference to a constexpr host variable
+  auto const ROWS_PER_BLOCK = NUM_STRING_ROWS_PER_BLOCK_FROM_ROWS;
+  auto const tiles_per_col  = util::div_rounding_up_unsafe(num_rows, ROWS_PER_BLOCK);
+  auto const starting_tile  = blockIdx.x * warp.meta_group_size() + warp.meta_group_rank();
+  auto const num_tiles      = tiles_per_col * num_string_columns;
+  auto const tile_stride    = warp.meta_group_size() * gridDim.x;
+  // Each warp will copy strings in its tile. This is handled by all the threads of a warp passing
+  // the same parameters to async_memcpy and all threads in the warp participating in the copy.
+  for (auto my_tile = starting_tile; my_tile < num_tiles; my_tile += tile_stride) {
+    auto const starting_row = (my_tile % tiles_per_col) * ROWS_PER_BLOCK;
+    auto const col          = my_tile / tiles_per_col;
+    auto const str_len      = string_lengths[col];
+    auto const str_row_off  = string_row_offsets[col];
+    auto const str_col_off  = string_column_offsets[col];
+    auto str_col_data       = string_col_data[col];
+    for (int row = starting_row; row < starting_row + ROWS_PER_BLOCK && row < num_rows; ++row) {
+      auto const src = &row_data[row_offsets(row, 0) + str_row_off[row]];
+      auto dst       = &str_col_data[str_col_off[row]];
+
+      cuda::memcpy_async(warp, dst, src, str_len[row], block_barrier);
+    }
+  }
+}
+
+/**
+ * @brief Calculate the dimensions of the kernel for fixed width only columns.
+ *
+ * @param [in] num_columns the number of columns being copied.
+ * @param [in] num_rows the number of rows being copied.
+ * @param [in] size_per_row the size each row takes up when padded.
+ * @param [out] blocks the size of the blocks for the kernel
+ * @param [out] threads the size of the threads for the kernel
+ * @return the size in bytes of shared memory needed for each block.
+ */
+static int calc_fixed_width_kernel_dims(const size_type num_columns,
+                                        const size_type num_rows,
+                                        const size_type size_per_row,
+                                        dim3& blocks,
+                                        dim3& threads)
+{
+  // We have found speed degrades when a thread handles more than 4 columns.
+  // Each block is 2 dimensional. The y dimension indicates the columns.
+  // We limit this to 32 threads in the y dimension so we can still
+  // have at least 32 threads in the x dimension (1 warp) which should
+  // result in better coalescing of memory operations. We also
+  // want to guarantee that we are processing a multiple of 32 threads
+  // in the x dimension because we use atomic operations at the block
+  // level when writing validity data out to main memory, and that would
+  // need to change if we split a word of validity data between blocks.
+  int const y_block_size          = min(util::div_rounding_up_safe(num_columns, 4), 32);
+  int const x_possible_block_size = 1024 / y_block_size;
+  // 48KB is the default setting for shared memory per block according to the cuda tutorials
+  // If someone configures the GPU to only have 16 KB this might not work.
+  int const max_shared_size = 48 * 1024;
+  // If we don't have enough shared memory there is no point in having more threads
+  // per block that will just sit idle
+  auto const max_block_size = std::min(x_possible_block_size, max_shared_size / size_per_row);
+  // Make sure that the x dimension is a multiple of 32 this not only helps
+  // coalesce memory access it also lets us do a ballot sync for validity to write
+  // the data back out the warp level.  If x is a multiple of 32 then each thread in the y
+  // dimension is associated with one or more warps, that should correspond to the validity
+  // words directly.
+  int const block_size = (max_block_size / 32) * 32;
+  CUDF_EXPECTS(block_size != 0, "Row size is too large to fit in shared memory");
+
+  // The maximum number of blocks supported in the x dimension is 2 ^ 31 - 1
+  // but in practice having too many can cause some overhead that I don't totally
+  // understand. Playing around with this having as little as 600 blocks appears
+  // to be able to saturate memory on V100, so this is an order of magnitude higher
+  // to try and future proof this a bit.
+  int const num_blocks = std::clamp((num_rows + block_size - 1) / block_size, 1, 10240);
+
+  blocks.x  = num_blocks;
+  blocks.y  = 1;
+  blocks.z  = 1;
+  threads.x = block_size;
+  threads.y = y_block_size;
+  threads.z = 1;
+  return size_per_row * block_size;
+}
+
+/**
+ * When converting to rows it is possible that the size of the table was too big to fit
+ * in a single column. This creates an output column for a subset of the rows in a table
+ * going from start row and containing the next num_rows.  Most of the parameters passed
+ * into this function are common between runs and should be calculated once.
+ */
+static std::unique_ptr<column> fixed_width_convert_to_rows(
+  const size_type start_row,
+  const size_type num_rows,
+  const size_type num_columns,
+  const size_type size_per_row,
+  rmm::device_uvector<size_type>& column_start,
+  rmm::device_uvector<size_type>& column_size,
+  rmm::device_uvector<const int8_t*>& input_data,
+  rmm::device_uvector<const bitmask_type*>& input_nm,
+  const scalar& zero,
+  const scalar& scalar_size_per_row,
+  rmm::cuda_stream_view stream,
+  rmm::mr::device_memory_resource* mr)
+{
+  int64_t const total_allocation = size_per_row * num_rows;
+  // We made a mistake in the split somehow
+  CUDF_EXPECTS(total_allocation < std::numeric_limits<size_type>::max(),
+               "Table is too large to fit!");
+
+  // Allocate and set the offsets row for the byte array
+  std::unique_ptr<column> offsets =
+    cudf::detail::sequence(num_rows + 1, zero, scalar_size_per_row, stream, mr);
+
+  std::unique_ptr<column> data = make_numeric_column(data_type(type_id::INT8),
+                                                     static_cast<size_type>(total_allocation),
+                                                     mask_state::UNALLOCATED,
+                                                     stream,
+                                                     mr);
+
+  dim3 blocks;
+  dim3 threads;
+  int shared_size =
+    detail::calc_fixed_width_kernel_dims(num_columns, num_rows, size_per_row, blocks, threads);
+
+  copy_to_rows_fixed_width_optimized<<<blocks, threads, shared_size, stream.value()>>>(
+    start_row,
+    num_rows,
+    num_columns,
+    size_per_row,
+    column_start.data(),
+    column_size.data(),
+    input_data.data(),
+    input_nm.data(),
+    data->mutable_view().data<int8_t>());
+
+  return make_lists_column(num_rows,
+                           std::move(offsets),
+                           std::move(data),
+                           0,
+                           rmm::device_buffer{0, cudf::get_default_stream(), mr},
+                           stream,
+                           mr);
+}
+
+static inline bool are_all_fixed_width(std::vector<data_type> const& schema)
+{
+  return std::all_of(
+    schema.begin(), schema.end(), [](const data_type& t) { return is_fixed_width(t); });
+}
+
+/**
+ * @brief Given a set of fixed width columns, calculate how the data will be laid out in memory.
+ *
+ * @param [in] schema the types of columns that need to be laid out.
+ * @param [out] column_start the byte offset where each column starts in the row.
+ * @param [out] column_size the size in bytes of the data for each columns in the row.
+ * @return the size in bytes each row needs.
+ */
+static inline int32_t compute_fixed_width_layout(std::vector<data_type> const& schema,
+                                                 std::vector<size_type>& column_start,
+                                                 std::vector<size_type>& column_size)
+{
+  // We guarantee that the start of each column is 64-bit aligned so anything can go
+  // there, but to make the code simple we will still do an alignment for it.
+  int32_t at_offset = 0;
+  for (auto col = schema.begin(); col < schema.end(); col++) {
+    size_type s = size_of(*col);
+    column_size.emplace_back(s);
+    std::size_t allocation_needed = s;
+    std::size_t alignment_needed  = allocation_needed;  // They are the same for fixed width types
+    at_offset = util::round_up_unsafe(at_offset, static_cast<int32_t>(alignment_needed));
+    column_start.emplace_back(at_offset);
+    at_offset += allocation_needed;
+  }
+
+  // Now we need to add in space for validity
+  // Eventually we can think about nullable vs not nullable, but for now we will just always add
+  // it in
+  int32_t const validity_bytes_needed =
+    util::div_rounding_up_safe<int32_t>(schema.size(), CHAR_BIT);
+  // validity comes at the end and is byte aligned so we can pack more in.
+  at_offset += validity_bytes_needed;
+  // Now we need to pad the end so all rows are 64 bit aligned
+  return util::round_up_unsafe(at_offset, JCUDF_ROW_ALIGNMENT);
+}
+
+/**
+ * @brief column sizes and column start offsets for a table
+ */
+struct column_info_s {
+  size_type size_per_row;
+  std::vector<size_type> column_starts;
+  std::vector<size_type> column_sizes;
+  std::vector<size_type> variable_width_column_starts;
+
+  column_info_s& operator=(column_info_s const& other) = delete;
+  column_info_s& operator=(column_info_s&& other)      = delete;
+};
+
+/**
+ * @brief Compute information about a table such as bytes per row and offsets.
+ *
+ * @tparam iterator iterator of column schema data
+ * @param begin starting iterator of column schema
+ * @param end ending iterator of column schema
+ * @param column_starts column start offsets
+ * @param column_sizes size in bytes of each column
+ * @return size of the fixed_width data portion of a row.
+ */
+template <typename iterator>
+column_info_s compute_column_information(iterator begin, iterator end)
+{
+  size_type size_per_row = 0;
+  std::vector<size_type> column_starts;
+  std::vector<size_type> column_sizes;
+  std::vector<size_type> variable_width_column_starts;
+
+  column_starts.reserve(std::distance(begin, end) + 1);
+  column_sizes.reserve(std::distance(begin, end));
+
+  for (auto col_type = begin; col_type != end; ++col_type) {
+    bool const compound_type = is_compound(*col_type);
+
+    // a list or string column will write a single uint64 of data here for offset/length
+    auto const col_size = compound_type ? sizeof(uint32_t) + sizeof(uint32_t) : size_of(*col_type);
+
+    // align size for this type - They are the same for fixed width types and 4 bytes for variable
+    // width length/offset combos
+    size_type const alignment_needed = compound_type ? __alignof(uint32_t) : col_size;
+    size_per_row                     = util::round_up_unsafe(size_per_row, alignment_needed);
+    if (compound_type) { variable_width_column_starts.push_back(size_per_row); }
+    column_starts.push_back(size_per_row);
+    column_sizes.push_back(col_size);
+    size_per_row += col_size;
+  }
+
+  // add validity offset to the end of fixed_width offsets
+  auto validity_offset = size_per_row;
+  column_starts.push_back(validity_offset);
+
+  // validity is byte-aligned in the JCUDF format
+  size_per_row +=
+    util::div_rounding_up_safe(static_cast<size_type>(std::distance(begin, end)), CHAR_BIT);
+
+  return {size_per_row,
+          std::move(column_starts),
+          std::move(column_sizes),
+          std::move(variable_width_column_starts)};
+}
+
+/**
+ * @brief Build `tile_info` for the validity data to break up the work.
+ *
+ * @param num_columns number of columns in the table
+ * @param num_rows number of rows in the table
+ * @param shmem_limit_per_tile size of shared memory available to a single gpu tile
+ * @param row_batches batched row information for multiple output locations
+ * @return vector of `tile_info` structs for validity data
+ */
+std::vector<detail::tile_info> build_validity_tile_infos(size_type const& num_columns,
+                                                         size_type const& num_rows,
+                                                         size_type const& shmem_limit_per_tile,
+                                                         std::vector<row_batch> const& row_batches)
+{
+  auto const desired_rows_and_columns = static_cast<int>(sqrt(shmem_limit_per_tile));
+  auto const column_stride            = util::round_up_unsafe(
+    [&]() {
+      if (desired_rows_and_columns > num_columns) {
+        // not many columns, build a single tile for table width and ship it off
+        return num_columns;
+      } else {
+        return util::round_down_safe(desired_rows_and_columns, CHAR_BIT);
+      }
+    }(),
+    JCUDF_ROW_ALIGNMENT);
+
+  // we fit as much as we can given the column stride note that an element in the table takes just 1
+  // bit, but a row with a single element still takes 8 bytes!
+  auto const bytes_per_row =
+    util::round_up_safe(util::div_rounding_up_unsafe(column_stride, CHAR_BIT), JCUDF_ROW_ALIGNMENT);
+  auto const row_stride =
+    std::min(num_rows, util::round_down_safe(shmem_limit_per_tile / bytes_per_row, 64));
+  std::vector<detail::tile_info> validity_tile_infos;
+  validity_tile_infos.reserve(num_columns / column_stride * num_rows / row_stride);
+  for (int col = 0; col < num_columns; col += column_stride) {
+    int current_tile_row_batch = 0;
+    int rows_left_in_batch     = row_batches[current_tile_row_batch].row_count;
+    int row                    = 0;
+    while (row < num_rows) {
+      if (rows_left_in_batch == 0) {
+        current_tile_row_batch++;
+        rows_left_in_batch = row_batches[current_tile_row_batch].row_count;
+      }
+      int const tile_height = std::min(row_stride, rows_left_in_batch);
+      validity_tile_infos.emplace_back(
+        detail::tile_info{col,
+                          row,
+                          std::min(col + column_stride - 1, num_columns - 1),
+                          row + tile_height - 1,
+                          current_tile_row_batch});
+      row += tile_height;
+      rows_left_in_batch -= tile_height;
+    }
+  }
+
+  return validity_tile_infos;
+}
+
+/**
+ * @brief functor that returns the size of a row or 0 is row is greater than the number of rows in
+ * the table
+ *
+ * @tparam RowSize iterator that returns the size of a specific row
+ */
+template <typename RowSize>
+struct row_size_functor {
+  row_size_functor(size_type row_end, RowSize row_sizes, size_type last_row_end)
+    : _row_end(row_end), _row_sizes(row_sizes), _last_row_end(last_row_end)
+  {
+  }
+
+  __device__ inline uint64_t operator()(int i) const
+  {
+    return i >= _row_end ? 0 : _row_sizes[i + _last_row_end];
+  }
+
+  size_type _row_end;
+  RowSize _row_sizes;
+  size_type _last_row_end;
+};
+
+/**
+ * @brief Builds batches of rows that will fit in the size limit of a column.
+ *
+ * @tparam RowSize iterator that gives the size of a specific row of the table.
+ * @param num_rows Total number of rows in the table
+ * @param row_sizes iterator that gives the size of a specific row of the table.
+ * @param all_fixed_width bool indicating all data in this table is fixed width
+ * @param stream stream to operate on for this work
+ * @param mr memory resource used to allocate any returned data
+ * @returns vector of size_type's that indicate row numbers for batch boundaries and a
+ * device_uvector of row offsets
+ */
+template <typename RowSize>
+batch_data build_batches(size_type num_rows,
+                         RowSize row_sizes,
+                         bool all_fixed_width,
+                         rmm::cuda_stream_view stream,
+                         rmm::mr::device_memory_resource* mr)
+{
+  auto const total_size = thrust::reduce(rmm::exec_policy(stream), row_sizes, row_sizes + num_rows);
+  auto const num_batches = static_cast<int32_t>(
+    util::div_rounding_up_safe(total_size, static_cast<uint64_t>(MAX_BATCH_SIZE)));
+  auto const num_offsets = num_batches + 1;
+  std::vector<row_batch> row_batches;
+  std::vector<size_type> batch_row_boundaries;
+  device_uvector<size_type> batch_row_offsets(all_fixed_width ? 0 : num_rows, stream);
+
+  // at most max gpu memory / 2GB iterations.
+  batch_row_boundaries.reserve(num_offsets);
+  batch_row_boundaries.push_back(0);
+  size_type last_row_end = 0;
+  device_uvector<uint64_t> cumulative_row_sizes(num_rows, stream);
+
+  thrust::inclusive_scan(
+    rmm::exec_policy(stream), row_sizes, row_sizes + num_rows, cumulative_row_sizes.begin());
+
+  // This needs to be split this into 2 gig batches. Care must be taken to avoid a batch larger than
+  // 2 gigs. Imagine a table with 900 meg rows. The batches should occur every 2 rows, but if a
+  // lower bound is run at 2 gigs, 4 gigs, 6 gigs. the batches will be 2 rows, 2 rows, 3 rows, which
+  // will be invalid. The previous batch size must be taken into account when building a new batch.
+  // One way is to pull the batch size back to the host and add it to MAX_BATCH_SIZE for the lower
+  // bound search. The other method involves keeping everything on device, but subtracting the
+  // previous batch from cumulative_row_sizes based on index. This involves no synchronization
+  // between GPU and CPU, but involves more work on the GPU. These further need to be broken on a
+  // 32-row boundary to match the fixed_width optimized versions.
+
+  while (last_row_end < num_rows) {
+    auto offset_row_sizes = thrust::make_transform_iterator(
+      cumulative_row_sizes.begin(),
+      cuda::proclaim_return_type<uint64_t>(
+        [last_row_end, cumulative_row_sizes = cumulative_row_sizes.data()] __device__(auto i) {
+          return i - cumulative_row_sizes[last_row_end];
+        }));
+    auto search_start = offset_row_sizes + last_row_end;
+    auto search_end   = offset_row_sizes + num_rows;
+
+    // find the next MAX_BATCH_SIZE boundary
+    auto const lb =
+      thrust::lower_bound(rmm::exec_policy(stream), search_start, search_end, MAX_BATCH_SIZE);
+    size_type const batch_size = lb - search_start;
+
+    size_type const row_end = lb == search_end
+                                ? batch_size + last_row_end
+                                : last_row_end + util::round_down_safe(batch_size, 32);
+
+    // build offset list for each row in this batch
+    auto const num_rows_in_batch = row_end - last_row_end;
+
+    // build offset list for each row in this batch
+    auto const num_entries = row_end - last_row_end + 1;
+    device_uvector<size_type> output_batch_row_offsets(num_entries, stream, mr);
+
+    auto row_size_iter_bounded = cudf::detail::make_counting_transform_iterator(
+      0, row_size_functor(row_end, row_sizes, last_row_end));
+
+    thrust::exclusive_scan(rmm::exec_policy(stream),
+                           row_size_iter_bounded,
+                           row_size_iter_bounded + num_entries,
+                           output_batch_row_offsets.begin());
+
+    auto const batch_bytes = output_batch_row_offsets.element(num_rows_in_batch, stream);
+
+    // The output_batch_row_offsets vector is used as the offset column of the returned data. This
+    // needs to be individually allocated, but the kernel needs a contiguous array of offsets or
+    // more global lookups are necessary.
+    if (!all_fixed_width) {
+      cudaMemcpy(batch_row_offsets.data() + last_row_end,
+                 output_batch_row_offsets.data(),
+                 num_rows_in_batch * sizeof(size_type),
+                 cudaMemcpyDeviceToDevice);
+    }
+
+    batch_row_boundaries.push_back(row_end);
+    row_batches.push_back({batch_bytes, num_rows_in_batch, std::move(output_batch_row_offsets)});
+
+    last_row_end = row_end;
+  }
+
+  return {
+    std::move(batch_row_offsets),
+    make_device_uvector_async(batch_row_boundaries, stream, rmm::mr::get_current_device_resource()),
+    std::move(batch_row_boundaries),
+    std::move(row_batches)};
+}
+
+/**
+ * @brief Computes the number of tiles necessary given a tile height and batch offsets
+ *
+ * @param batch_row_boundaries row boundaries for each batch
+ * @param desired_tile_height height of each tile in the table
+ * @param stream stream to use
+ * @return number of tiles necessary
+ */
+int compute_tile_counts(device_span<size_type const> const& batch_row_boundaries,
+                        int desired_tile_height,
+                        rmm::cuda_stream_view stream)
+{
+  size_type const num_batches = batch_row_boundaries.size() - 1;
+  device_uvector<size_type> num_tiles(num_batches, stream);
+  auto iter = thrust::make_counting_iterator(0);
+  thrust::transform(
+    rmm::exec_policy(stream),
+    iter,
+    iter + num_batches,
+    num_tiles.begin(),
+    cuda::proclaim_return_type<size_type>(
+      [desired_tile_height, batch_row_boundaries = batch_row_boundaries.data()] __device__(
+        auto batch_index) -> size_type {
+        return util::div_rounding_up_unsafe(
+          batch_row_boundaries[batch_index + 1] - batch_row_boundaries[batch_index],
+          desired_tile_height);
+      }));
+  return thrust::reduce(rmm::exec_policy(stream), num_tiles.begin(), num_tiles.end());
+}
+
+/**
+ * @brief Builds the `tile_info` structs for a given table.
+ *
+ * @param tiles span of tiles to populate
+ * @param batch_row_boundaries boundary to row batches
+ * @param column_start starting column of the tile
+ * @param column_end ending column of the tile
+ * @param desired_tile_height height of the tile
+ * @param total_number_of_rows total number of rows in the table
+ * @param stream stream to use
+ * @return number of tiles created
+ */
+size_type build_tiles(
+  device_span<tile_info> tiles,
+  device_uvector<size_type> const& batch_row_boundaries,  // comes from build_batches
+  int column_start,
+  int column_end,
+  int desired_tile_height,
+  int total_number_of_rows,
+  rmm::cuda_stream_view stream)
+{
+  size_type const num_batches = batch_row_boundaries.size() - 1;
+  device_uvector<size_type> num_tiles(num_batches, stream);
+  auto iter = thrust::make_counting_iterator(0);
+  thrust::transform(
+    rmm::exec_policy(stream),
+    iter,
+    iter + num_batches,
+    num_tiles.begin(),
+    cuda::proclaim_return_type<size_type>(
+      [desired_tile_height, batch_row_boundaries = batch_row_boundaries.data()] __device__(
+        auto batch_index) -> size_type {
+        return util::div_rounding_up_unsafe(
+          batch_row_boundaries[batch_index + 1] - batch_row_boundaries[batch_index],
+          desired_tile_height);
+      }));
+
+  size_type const total_tiles =
+    thrust::reduce(rmm::exec_policy(stream), num_tiles.begin(), num_tiles.end());
+
+  device_uvector<size_type> tile_starts(num_batches + 1, stream);
+  auto tile_iter = cudf::detail::make_counting_transform_iterator(
+    0,
+    cuda::proclaim_return_type<size_type>(
+      [num_tiles = num_tiles.data(), num_batches] __device__(auto i) {
+        return (i < num_batches) ? num_tiles[i] : 0;
+      }));
+  thrust::exclusive_scan(rmm::exec_policy(stream),
+                         tile_iter,
+                         tile_iter + num_batches + 1,
+                         tile_starts.begin());  // in tiles
+
+  thrust::transform(
+    rmm::exec_policy(stream),
+    iter,
+    iter + total_tiles,
+    tiles.begin(),
+    cuda::proclaim_return_type<tile_info>(
+      [                     =,
+       tile_starts          = tile_starts.data(),
+       batch_row_boundaries = batch_row_boundaries.data()] __device__(size_type tile_index) {
+        // what batch this tile falls in
+        auto const batch_index_iter =
+          thrust::upper_bound(thrust::seq, tile_starts, tile_starts + num_batches, tile_index);
+        auto const batch_index = std::distance(tile_starts, batch_index_iter) - 1;
+        // local index within the tile
+        int const local_tile_index = tile_index - tile_starts[batch_index];
+        // the start row for this batch.
+        int const batch_row_start = batch_row_boundaries[batch_index];
+        // the start row for this tile
+        int const tile_row_start = batch_row_start + (local_tile_index * desired_tile_height);
+        // the end row for this tile
+        int const max_row =
+          std::min(total_number_of_rows - 1,
+                   batch_index + 1 > num_batches
+                     ? std::numeric_limits<size_type>::max()
+                     : static_cast<int>(batch_row_boundaries[batch_index + 1]) - 1);
+        int const tile_row_end =
+          std::min(batch_row_start + ((local_tile_index + 1) * desired_tile_height) - 1, max_row);
+
+        // stuff the tile
+        return tile_info{
+          column_start, tile_row_start, column_end, tile_row_end, static_cast<int>(batch_index)};
+      }));
+
+  return total_tiles;
+}
+
+/**
+ * @brief Determines what data should be operated on by each tile for the incoming table.
+ *
+ * @tparam TileCallback Callback that receives the start and end columns of tiles
+ * @param column_sizes vector of the size of each column
+ * @param column_starts vector of the offset of each column
+ * @param first_row_batch_size size of the first row batch to limit max tile size since a tile
+ * is unable to span batches
+ * @param total_number_of_rows total number of rows in the table
+ * @param shmem_limit_per_tile shared memory allowed per tile
+ * @param f callback function called when building a tile
+ */
+template <typename TileCallback>
+void determine_tiles(std::vector<size_type> const& column_sizes,
+                     std::vector<size_type> const& column_starts,
+                     size_type const first_row_batch_size,
+                     size_type const total_number_of_rows,
+                     size_type const& shmem_limit_per_tile,
+                     TileCallback f)
+{
+  // tile infos are organized with the tile going "down" the columns this provides the most
+  // coalescing of memory access
+  int current_tile_width     = 0;
+  int current_tile_start_col = 0;
+
+  // the ideal tile height has lots of 8-byte reads and 8-byte writes. The optimal read/write would
+  // be memory cache line sized access, but since other tiles will read/write the edges this may not
+  // turn out to be overly important. For now, we will attempt to build a square tile as far as byte
+  // sizes. x * y = shared_mem_size. Which translates to x^2 = shared_mem_size since we want them
+  // equal, so height and width are sqrt(shared_mem_size). The trick is that it's in bytes, not rows
+  // or columns.
+  auto const square_bias         = 32;  // bias towards columns for performance reasons
+  auto const optimal_square_len  = static_cast<size_type>(sqrt(shmem_limit_per_tile));
+  auto const desired_tile_height = util::round_up_safe<int>(
+    std::min(optimal_square_len / square_bias, total_number_of_rows), cudf::detail::warp_size);
+  auto const tile_height = std::clamp(desired_tile_height, 1, first_row_batch_size);
+
+  int row_size = 0;
+
+  // march each column and build the tiles of appropriate sizes
+  for (uint col = 0; col < column_sizes.size(); ++col) {
+    auto const col_size = column_sizes[col];
+
+    // align size for this type
+    auto const alignment_needed       = col_size;  // They are the same for fixed width types
+    auto const row_size_aligned       = util::round_up_unsafe(row_size, alignment_needed);
+    auto const row_size_with_this_col = row_size_aligned + col_size;
+    auto const row_size_with_end_pad =
+      util::round_up_unsafe(row_size_with_this_col, JCUDF_ROW_ALIGNMENT);
+
+    if (row_size_with_end_pad * tile_height > shmem_limit_per_tile) {
+      // too large, close this tile, generate vertical tiles and restart
+      f(current_tile_start_col, col == 0 ? col : col - 1, tile_height);
+
+      row_size =
+        util::round_up_unsafe((column_starts[col] + column_sizes[col]) & 7, alignment_needed);
+      row_size += col_size;  // alignment required for shared memory tile boundary to match
+                             // alignment of output row
+      current_tile_start_col = col;
+      current_tile_width     = 0;
+    } else {
+      row_size = row_size_with_this_col;
+      current_tile_width++;
+    }
+  }
+
+  // build last set of tiles
+  if (current_tile_width > 0) {
+    f(current_tile_start_col, static_cast<int>(column_sizes.size()) - 1, tile_height);
+  }
+}
+
+/**
+ * @brief convert cudf table into JCUDF row format
+ *
+ * @tparam offsetFunctor functor type for offset functor
+ * @param tbl table to convert to JCUDF row format
+ * @param batch_info information about the batches of data
+ * @param offset_functor functor that returns the starting offset of each row
+ * @param column_info information about incoming columns
+ * @param variable_width_offsets optional vector of offsets for variable-with columns
+ * @param stream stream used
+ * @param mr selected memory resource for returned data
+ * @return vector of list columns containing byte columns of the JCUDF row data
+ */
+template <typename offsetFunctor>
+std::vector<std::unique_ptr<column>> convert_to_rows(
+  table_view const& tbl,
+  batch_data& batch_info,
+  offsetFunctor offset_functor,
+  column_info_s const& column_info,
+  std::optional<rmm::device_uvector<cudf::detail::input_offsetalator>> variable_width_offsets,
+  rmm::cuda_stream_view stream,
+  rmm::mr::device_memory_resource* mr)
+{
+  int device_id;
+  CUDF_CUDA_TRY(cudaGetDevice(&device_id));
+  int total_shmem_in_bytes;
+  CUDF_CUDA_TRY(
+    cudaDeviceGetAttribute(&total_shmem_in_bytes, cudaDevAttrMaxSharedMemoryPerBlock, device_id));
+
+#ifndef __CUDA_ARCH__  // __host__ code.
+  // Need to reduce total shmem available by the size of barriers in the kernel's shared memory
+  total_shmem_in_bytes -=
+    util::round_up_unsafe(sizeof(cuda::barrier<cuda::thread_scope_block>), 16ul);
+#endif  // __CUDA_ARCH__
+
+  auto const shmem_limit_per_tile = total_shmem_in_bytes;
+
+  auto const num_rows         = tbl.num_rows();
+  auto const fixed_width_only = !variable_width_offsets.has_value();
+
+  auto select_columns = [](auto const& tbl, auto column_predicate) {
+    std::vector<column_view> cols;
+    std::copy_if(tbl.begin(), tbl.end(), std::back_inserter(cols), [&](auto c) {
+      return column_predicate(c);
+    });
+    return table_view(cols);
+  };
+
+  auto dev_col_sizes = make_device_uvector_async(
+    column_info.column_sizes, stream, rmm::mr::get_current_device_resource());
+  auto dev_col_starts = make_device_uvector_async(
+    column_info.column_starts, stream, rmm::mr::get_current_device_resource());
+
+  // Get the pointers to the input columnar data ready
+  auto const data_begin = thrust::make_transform_iterator(tbl.begin(), [](auto const& c) {
+    return is_compound(c.type()) ? nullptr : c.template data<int8_t>();
+  });
+  std::vector<int8_t const*> input_data(data_begin, data_begin + tbl.num_columns());
+
+  // validity code handles variable and fixed-width data, so give it everything
+  auto const nm_begin =
+    thrust::make_transform_iterator(tbl.begin(), [](auto const& c) { return c.null_mask(); });
+  std::vector<bitmask_type const*> input_nm(nm_begin, nm_begin + tbl.num_columns());
+
+  auto dev_input_data =
+    make_device_uvector_async(input_data, stream, rmm::mr::get_current_device_resource());
+  auto dev_input_nm =
+    make_device_uvector_async(input_nm, stream, rmm::mr::get_current_device_resource());
+
+  // the first batch always exists unless we were sent an empty table
+  auto const first_batch_size = batch_info.row_batches[0].row_count;
+
+  std::vector<rmm::device_buffer> output_buffers;
+  std::vector<int8_t*> output_data;
+  output_data.reserve(batch_info.row_batches.size());
+  output_buffers.reserve(batch_info.row_batches.size());
+  std::transform(
+    batch_info.row_batches.begin(),
+    batch_info.row_batches.end(),
+    std::back_inserter(output_buffers),
+    [&](auto const& batch) { return rmm::device_buffer(batch.num_bytes, stream, mr); });
+  std::transform(
+    output_buffers.begin(), output_buffers.end(), std::back_inserter(output_data), [](auto& buf) {
+      return static_cast<int8_t*>(buf.data());
+    });
+
+  auto dev_output_data = make_device_uvector_async(output_data, stream, mr);
+
+  int info_count = 0;
+  detail::determine_tiles(
+    column_info.column_sizes,
+    column_info.column_starts,
+    first_batch_size,
+    num_rows,
+    shmem_limit_per_tile,
+    [&gpu_batch_row_boundaries = batch_info.d_batch_row_boundaries, &info_count, &stream](
+      int const start_col, int const end_col, int const tile_height) {
+      int i = detail::compute_tile_counts(gpu_batch_row_boundaries, tile_height, stream);
+      info_count += i;
+    });
+
+  // allocate space for tiles
+  device_uvector<detail::tile_info> gpu_tile_infos(info_count, stream);
+  int tile_offset = 0;
+
+  detail::determine_tiles(
+    column_info.column_sizes,
+    column_info.column_starts,
+    first_batch_size,
+    num_rows,
+    shmem_limit_per_tile,
+    [&gpu_batch_row_boundaries = batch_info.d_batch_row_boundaries,
+     &gpu_tile_infos,
+     num_rows,
+     &tile_offset,
+     stream](int const start_col, int const end_col, int const tile_height) {
+      tile_offset += detail::build_tiles(
+        {gpu_tile_infos.data() + tile_offset, gpu_tile_infos.size() - tile_offset},
+        gpu_batch_row_boundaries,
+        start_col,
+        end_col,
+        tile_height,
+        num_rows,
+        stream);
+    });
+
+  // build validity tiles for ALL columns, variable and fixed width.
+  auto validity_tile_infos = detail::build_validity_tile_infos(
+    tbl.num_columns(), num_rows, shmem_limit_per_tile, batch_info.row_batches);
+
+  auto dev_validity_tile_infos =
+    make_device_uvector_async(validity_tile_infos, stream, rmm::mr::get_current_device_resource());
+
+  auto const validity_offset = column_info.column_starts.back();
+
+  // blast through the entire table and convert it
+  detail::copy_to_rows<<<gpu_tile_infos.size(),
+                         NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                         total_shmem_in_bytes,
+                         stream.value()>>>(num_rows,
+                                           tbl.num_columns(),
+                                           shmem_limit_per_tile,
+                                           gpu_tile_infos,
+                                           dev_input_data.data(),
+                                           dev_col_sizes.data(),
+                                           dev_col_starts.data(),
+                                           offset_functor,
+                                           batch_info.d_batch_row_boundaries.data(),
+                                           reinterpret_cast<int8_t**>(dev_output_data.data()));
+
+  // note that validity gets the entire table and not the fixed-width portion
+  detail::copy_validity_to_rows<<<validity_tile_infos.size(),
+                                  NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                                  total_shmem_in_bytes,
+                                  stream.value()>>>(num_rows,
+                                                    tbl.num_columns(),
+                                                    shmem_limit_per_tile,
+                                                    offset_functor,
+                                                    batch_info.d_batch_row_boundaries.data(),
+                                                    dev_output_data.data(),
+                                                    validity_offset,
+                                                    dev_validity_tile_infos,
+                                                    dev_input_nm.data());
+
+  if (!fixed_width_only) {
+    // build table view for variable-width data only
+    auto const variable_width_table =
+      select_columns(tbl, [](auto col) { return is_compound(col.type()); });
+
+    CUDF_EXPECTS(!variable_width_table.is_empty(), "No variable-width columns when expected!");
+    CUDF_EXPECTS(variable_width_offsets.has_value(), "No variable width offset data!");
+
+    auto const variable_data_begin = thrust::make_transform_iterator(
+      variable_width_table.begin(),
+      [](auto const& c) { return is_compound(c.type()) ? c.template data<int8_t>() : nullptr; });
+    std::vector<int8_t const*> variable_width_input_data(
+      variable_data_begin, variable_data_begin + variable_width_table.num_columns());
+
+    auto dev_variable_input_data = make_device_uvector_async(
+      variable_width_input_data, stream, rmm::mr::get_current_device_resource());
+    auto dev_variable_col_output_offsets = make_device_uvector_async(
+      column_info.variable_width_column_starts, stream, rmm::mr::get_current_device_resource());
+
+    for (uint i = 0; i < batch_info.row_batches.size(); i++) {
+      auto const batch_row_offset = batch_info.batch_row_boundaries[i];
+      auto const batch_num_rows   = batch_info.row_batches[i].row_count;
+
+      dim3 const string_blocks(
+        std::min(MAX_STRING_BLOCKS,
+                 util::div_rounding_up_unsafe(batch_num_rows, NUM_STRING_ROWS_PER_BLOCK_TO_ROWS)));
+
+      detail::copy_strings_to_rows<<<string_blocks,
+                                     NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                                     0,
+                                     stream.value()>>>(batch_num_rows,
+                                                       variable_width_table.num_columns(),
+                                                       dev_variable_input_data.data(),
+                                                       dev_variable_col_output_offsets.data(),
+                                                       variable_width_offsets->data(),
+                                                       column_info.size_per_row,
+                                                       offset_functor,
+                                                       batch_row_offset,
+                                                       reinterpret_cast<int8_t*>(output_data[i]));
+    }
+  }
+
+  // split up the output buffer into multiple buffers based on row batch sizes and create list of
+  // byte columns
+  std::vector<std::unique_ptr<column>> ret;
+  ret.reserve(batch_info.row_batches.size());
+  auto counting_iter = thrust::make_counting_iterator(0);
+  std::transform(counting_iter,
+                 counting_iter + batch_info.row_batches.size(),
+                 std::back_inserter(ret),
+                 [&](auto batch) {
+                   auto const offset_count = batch_info.row_batches[batch].row_offsets.size();
+                   auto offsets =
+                     std::make_unique<column>(data_type{type_id::INT32},
+                                              (size_type)offset_count,
+                                              batch_info.row_batches[batch].row_offsets.release(),
+                                              rmm::device_buffer{},
+                                              0);
+                   auto data = std::make_unique<column>(data_type{type_id::INT8},
+                                                        batch_info.row_batches[batch].num_bytes,
+                                                        std::move(output_buffers[batch]),
+                                                        rmm::device_buffer{},
+                                                        0);
+
+                   return make_lists_column(batch_info.row_batches[batch].row_count,
+                                            std::move(offsets),
+                                            std::move(data),
+                                            0,
+                                            rmm::device_buffer{0, cudf::get_default_stream(), mr},
+                                            stream,
+                                            mr);
+                 });
+
+  return ret;
+}
+
+}  // namespace detail
+
+/**
+ * @brief convert a cudf table to JCUDF row format
+ *
+ * @param tbl incoming table to convert
+ * @param stream stream to use for operations
+ * @param mr memory resource used for returned data
+ * @return vector of list columns containing byte columns of the JCUDF row data
+ */
+std::vector<std::unique_ptr<column>> convert_to_rows(table_view const& tbl,
+                                                     rmm::cuda_stream_view stream,
+                                                     rmm::mr::device_memory_resource* mr)
+{
+  auto const num_columns = tbl.num_columns();
+  auto const num_rows    = tbl.num_rows();
+
+  auto const fixed_width_only = std::all_of(
+    tbl.begin(), tbl.end(), [](column_view const& c) { return is_fixed_width(c.type()); });
+
+  // Break up the work into tiles, which are a starting and ending row/col #. This tile size is
+  // calculated based on the shared memory size available we want a single tile to fill up the
+  // entire shared memory space available for the transpose-like conversion.
+
+  // There are two different processes going on here. The GPU conversion of the data and the writing
+  // of the data into the list of byte columns that are a maximum of 2 gigs each due to offset
+  // maximum size. The GPU conversion portion has to understand this limitation because the column
+  // must own the data inside and as a result it must be a distinct allocation for that column.
+  // Copying the data into these final buffers would be prohibitively expensive, so care is taken to
+  // ensure the GPU writes to the proper buffer. The tiles are broken at the boundaries of specific
+  // rows based on the row sizes up to that point. These are row batches and they are decided first
+  // before building the tiles so the tiles can be properly cut around them.
+
+  auto schema_column_iter =
+    thrust::make_transform_iterator(tbl.begin(), [](auto const& i) { return i.type(); });
+
+  auto column_info =
+    detail::compute_column_information(schema_column_iter, schema_column_iter + num_columns);
+  auto const size_per_row = column_info.size_per_row;
+  if (fixed_width_only) {
+    // total encoded row size. This includes fixed-width data and validity only. It does not include
+    // variable-width data since it isn't copied with the fixed-width and validity kernel.
+    auto row_size_iter = thrust::make_constant_iterator<uint64_t>(
+      util::round_up_unsafe(size_per_row, JCUDF_ROW_ALIGNMENT));
+
+    auto batch_info = detail::build_batches(num_rows, row_size_iter, fixed_width_only, stream, mr);
+
+    detail::fixed_width_row_offset_functor offset_functor(
+      util::round_up_unsafe(size_per_row, JCUDF_ROW_ALIGNMENT));
+
+    return detail::convert_to_rows(
+      tbl, batch_info, offset_functor, std::move(column_info), std::nullopt, stream, mr);
+  } else {
+    auto offset_data = detail::build_string_row_offsets(tbl, size_per_row, stream);
+    auto& row_sizes  = std::get<0>(offset_data);
+
+    auto row_size_iter = cudf::detail::make_counting_transform_iterator(
+      0, detail::row_size_functor(num_rows, row_sizes.data(), 0));
+
+    auto batch_info = detail::build_batches(num_rows, row_size_iter, fixed_width_only, stream, mr);
+
+    detail::string_row_offset_functor offset_functor(batch_info.batch_row_offsets);
+
+    return detail::convert_to_rows(tbl,
+                                   batch_info,
+                                   offset_functor,
+                                   std::move(column_info),
+                                   std::make_optional(std::move(std::get<1>(offset_data))),
+                                   stream,
+                                   mr);
+  }
+}
+
+std::vector<std::unique_ptr<column>> convert_to_rows_fixed_width_optimized(
+  table_view const& tbl, rmm::cuda_stream_view stream, rmm::mr::device_memory_resource* mr)
+{
+  auto const num_columns = tbl.num_columns();
+
+  std::vector<data_type> schema;
+  schema.resize(num_columns);
+  std::transform(
+    tbl.begin(), tbl.end(), schema.begin(), [](auto i) -> data_type { return i.type(); });
+
+  if (detail::are_all_fixed_width(schema)) {
+    std::vector<size_type> column_start;
+    std::vector<size_type> column_size;
+
+    int32_t const size_per_row =
+      detail::compute_fixed_width_layout(schema, column_start, column_size);
+    auto dev_column_start = make_device_uvector_async(column_start, stream, mr);
+    auto dev_column_size  = make_device_uvector_async(column_size, stream, mr);
+
+    // Make the number of rows per batch a multiple of 32 so we don't have to worry about splitting
+    // validity at a specific row offset.  This might change in the future.
+    auto const max_rows_per_batch =
+      util::round_down_safe(std::numeric_limits<size_type>::max() / size_per_row, 32);
+
+    auto const num_rows = tbl.num_rows();
+
+    // Get the pointers to the input columnar data ready
+    std::vector<const int8_t*> input_data;
+    std::vector<bitmask_type const*> input_nm;
+    for (size_type column_number = 0; column_number < num_columns; column_number++) {
+      column_view cv = tbl.column(column_number);
+      input_data.emplace_back(cv.data<int8_t>());
+      input_nm.emplace_back(cv.null_mask());
+    }
+    auto dev_input_data = make_device_uvector_async(input_data, stream, mr);
+    auto dev_input_nm   = make_device_uvector_async(input_nm, stream, mr);
+
+    using ScalarType = scalar_type_t<size_type>;
+    auto zero        = make_numeric_scalar(data_type(type_id::INT32), stream.value());
+    zero->set_valid_async(true, stream);
+    static_cast<ScalarType*>(zero.get())->set_value(0, stream);
+
+    auto step = make_numeric_scalar(data_type(type_id::INT32), stream.value());
+    step->set_valid_async(true, stream);
+    static_cast<ScalarType*>(step.get())->set_value(static_cast<size_type>(size_per_row), stream);
+
+    std::vector<std::unique_ptr<column>> ret;
+    for (size_type row_start = 0; row_start < num_rows; row_start += max_rows_per_batch) {
+      size_type row_count = num_rows - row_start;
+      row_count           = row_count > max_rows_per_batch ? max_rows_per_batch : row_count;
+      ret.emplace_back(detail::fixed_width_convert_to_rows(row_start,
+                                                           row_count,
+                                                           num_columns,
+                                                           size_per_row,
+                                                           dev_column_start,
+                                                           dev_column_size,
+                                                           dev_input_data,
+                                                           dev_input_nm,
+                                                           *zero,
+                                                           *step,
+                                                           stream,
+                                                           mr));
+    }
+
+    return ret;
+  } else {
+    CUDF_FAIL("Only fixed width types are currently supported");
+  }
+}
+
+namespace {
+
+/// @brief Calculates and sets null counts for specified columns
+void fixup_null_counts(std::vector<std::unique_ptr<column>>& output_columns,
+                       rmm::cuda_stream_view stream)
+{
+  for (auto& col : output_columns) {
+    col->set_null_count(cudf::detail::null_count(col->view().null_mask(), 0, col->size(), stream));
+  }
+}
+
+}  // namespace
+
+/**
+ * @brief convert from JCUDF row format to cudf columns
+ *
+ * @param input vector of list columns containing byte columns of the JCUDF row data
+ * @param schema incoming schema of the data
+ * @param stream stream to use for compute
+ * @param mr memory resource for returned data
+ * @return cudf table of the data
+ */
+std::unique_ptr<table> convert_from_rows(lists_column_view const& input,
+                                         std::vector<data_type> const& schema,
+                                         rmm::cuda_stream_view stream,
+                                         rmm::mr::device_memory_resource* mr)
+{
+  // verify that the types are what we expect
+  column_view child    = input.child();
+  auto const list_type = child.type().id();
+  CUDF_EXPECTS(list_type == type_id::INT8 || list_type == type_id::UINT8,
+               "Only a list of bytes is supported as input");
+
+  // convert any strings in the schema to two int32 columns
+  // This allows us to leverage the fixed-width copy code to fill in our offset and string length
+  // data.
+  std::vector<data_type> string_schema;
+  string_schema.reserve(schema.size());
+  for (auto i : schema) {
+    if (i.id() == type_id::STRING) {
+      string_schema.push_back(data_type(type_id::INT32));
+      string_schema.push_back(data_type(type_id::INT32));
+    } else {
+      string_schema.push_back(i);
+    }
+  }
+
+  auto const num_columns = string_schema.size();
+  auto const num_rows    = input.parent().size();
+
+  int device_id;
+  CUDF_CUDA_TRY(cudaGetDevice(&device_id));
+  int total_shmem_in_bytes;
+  CUDF_CUDA_TRY(
+    cudaDeviceGetAttribute(&total_shmem_in_bytes, cudaDevAttrMaxSharedMemoryPerBlock, device_id));
+
+#ifndef __CUDA_ARCH__  // __host__ code.
+  // Need to reduce total shmem available by the size of barriers in the kernel's shared memory
+  total_shmem_in_bytes -=
+    util::round_up_unsafe(sizeof(cuda::barrier<cuda::thread_scope_block>), 16ul);
+#endif  // __CUDA_ARCH__
+
+  auto const shmem_limit_per_tile = total_shmem_in_bytes;
+
+  auto column_info = detail::compute_column_information(string_schema.begin(), string_schema.end());
+  auto const size_per_row = util::round_up_unsafe(column_info.size_per_row, JCUDF_ROW_ALIGNMENT);
+
+  // Ideally we would check that the offsets are all the same, etc. but for now this is probably
+  // fine
+  CUDF_EXPECTS(size_per_row * num_rows <= child.size(), "The layout of the data appears to be off");
+  auto dev_col_starts = make_device_uvector_async(
+    column_info.column_starts, stream, rmm::mr::get_current_device_resource());
+  auto dev_col_sizes = make_device_uvector_async(
+    column_info.column_sizes, stream, rmm::mr::get_current_device_resource());
+
+  // Allocate the columns we are going to write into
+  std::vector<std::unique_ptr<column>> output_columns;
+  std::vector<std::unique_ptr<column>> string_row_offset_columns;
+  std::vector<std::unique_ptr<column>> string_length_columns;
+  std::vector<int8_t*> output_data;
+  std::vector<bitmask_type*> output_nm;
+  std::vector<int32_t*> string_row_offsets;
+  std::vector<int32_t*> string_lengths;
+  for (auto i : schema) {
+    auto make_col = [&output_data, &output_nm](data_type type,
+                                               size_type num_rows,
+                                               bool include_nm,
+                                               rmm::cuda_stream_view stream,
+                                               rmm::mr::device_memory_resource* mr) {
+      auto column =
+        make_fixed_width_column(type,
+                                num_rows,
+                                include_nm ? mask_state::UNINITIALIZED : mask_state::UNALLOCATED,
+                                stream,
+                                mr);
+      auto mut = column->mutable_view();
+      output_data.emplace_back(mut.data<int8_t>());
+      if (include_nm) { output_nm.emplace_back(mut.null_mask()); }
+      return column;
+    };
+    if (i.id() == type_id::STRING) {
+      auto const int32type = data_type(type_id::INT32);
+      auto offset_col =
+        make_col(int32type, num_rows, true, stream, rmm::mr::get_current_device_resource());
+      string_row_offsets.push_back(offset_col->mutable_view().data<int32_t>());
+      string_row_offset_columns.emplace_back(std::move(offset_col));
+      auto length_col =
+        make_col(int32type, num_rows, false, stream, rmm::mr::get_current_device_resource());
+      string_lengths.push_back(length_col->mutable_view().data<int32_t>());
+      string_length_columns.emplace_back(std::move(length_col));
+      // placeholder
+      output_columns.emplace_back(make_empty_column(type_id::STRING));
+    } else {
+      output_columns.emplace_back(make_col(i, num_rows, true, stream, mr));
+    }
+  }
+
+  auto dev_string_row_offsets =
+    make_device_uvector_async(string_row_offsets, stream, rmm::mr::get_current_device_resource());
+  auto dev_string_lengths =
+    make_device_uvector_async(string_lengths, stream, rmm::mr::get_current_device_resource());
+
+  // build the row_batches from the passed in list column
+  std::vector<detail::row_batch> row_batches;
+  row_batches.push_back(
+    {detail::row_batch{child.size(), num_rows, device_uvector<size_type>(0, stream)}});
+
+  auto dev_output_data =
+    make_device_uvector_async(output_data, stream, rmm::mr::get_current_device_resource());
+  auto dev_output_nm =
+    make_device_uvector_async(output_nm, stream, rmm::mr::get_current_device_resource());
+
+  // only ever get a single batch when going from rows, so boundaries are 0, num_rows
+  constexpr auto num_batches = 2;
+  device_uvector<size_type> gpu_batch_row_boundaries(num_batches, stream);
+
+  thrust::transform(rmm::exec_policy(stream),
+                    thrust::make_counting_iterator(0),
+                    thrust::make_counting_iterator(num_batches),
+                    gpu_batch_row_boundaries.begin(),
+                    cuda::proclaim_return_type<size_type>(
+                      [num_rows] __device__(auto i) { return i == 0 ? 0 : num_rows; }));
+
+  int info_count = 0;
+  detail::determine_tiles(column_info.column_sizes,
+                          column_info.column_starts,
+                          num_rows,
+                          num_rows,
+                          shmem_limit_per_tile,
+                          [&gpu_batch_row_boundaries, &info_count, &stream](
+                            int const start_col, int const end_col, int const tile_height) {
+                            info_count += detail::compute_tile_counts(
+                              gpu_batch_row_boundaries, tile_height, stream);
+                          });
+
+  // allocate space for tiles
+  device_uvector<detail::tile_info> gpu_tile_infos(info_count, stream);
+
+  int tile_offset = 0;
+  detail::determine_tiles(
+    column_info.column_sizes,
+    column_info.column_starts,
+    num_rows,
+    num_rows,
+    shmem_limit_per_tile,
+    [&gpu_batch_row_boundaries, &gpu_tile_infos, num_rows, &tile_offset, stream](
+      int const start_col, int const end_col, int const tile_height) {
+      tile_offset += detail::build_tiles(
+        {gpu_tile_infos.data() + tile_offset, gpu_tile_infos.size() - tile_offset},
+        gpu_batch_row_boundaries,
+        start_col,
+        end_col,
+        tile_height,
+        num_rows,
+        stream);
+    });
+
+  dim3 const blocks(gpu_tile_infos.size());
+
+  // validity needs to be calculated based on the actual number of final table columns
+  auto validity_tile_infos =
+    detail::build_validity_tile_infos(schema.size(), num_rows, shmem_limit_per_tile, row_batches);
+
+  auto dev_validity_tile_infos =
+    make_device_uvector_async(validity_tile_infos, stream, rmm::mr::get_current_device_resource());
+
+  dim3 const validity_blocks(validity_tile_infos.size());
+
+  if (dev_string_row_offsets.size() == 0) {
+    detail::fixed_width_row_offset_functor offset_functor(size_per_row);
+
+    detail::copy_from_rows<<<gpu_tile_infos.size(),
+                             NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                             total_shmem_in_bytes,
+                             stream.value()>>>(num_rows,
+                                               num_columns,
+                                               shmem_limit_per_tile,
+                                               offset_functor,
+                                               gpu_batch_row_boundaries.data(),
+                                               dev_output_data.data(),
+                                               dev_col_sizes.data(),
+                                               dev_col_starts.data(),
+                                               gpu_tile_infos,
+                                               child.data<int8_t>());
+
+    detail::copy_validity_from_rows<<<validity_tile_infos.size(),
+                                      NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                                      total_shmem_in_bytes,
+                                      stream.value()>>>(num_rows,
+                                                        num_columns,
+                                                        shmem_limit_per_tile,
+                                                        offset_functor,
+                                                        gpu_batch_row_boundaries.data(),
+                                                        dev_output_nm.data(),
+                                                        column_info.column_starts.back(),
+                                                        dev_validity_tile_infos,
+                                                        child.data<int8_t>());
+
+  } else {
+    detail::string_row_offset_functor offset_functor(device_span<size_type const>{input.offsets()});
+    detail::copy_from_rows<<<gpu_tile_infos.size(),
+                             NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                             total_shmem_in_bytes,
+                             stream.value()>>>(num_rows,
+                                               num_columns,
+                                               shmem_limit_per_tile,
+                                               offset_functor,
+                                               gpu_batch_row_boundaries.data(),
+                                               dev_output_data.data(),
+                                               dev_col_sizes.data(),
+                                               dev_col_starts.data(),
+                                               gpu_tile_infos,
+                                               child.data<int8_t>());
+
+    detail::copy_validity_from_rows<<<validity_tile_infos.size(),
+                                      NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                                      total_shmem_in_bytes,
+                                      stream.value()>>>(num_rows,
+                                                        num_columns,
+                                                        shmem_limit_per_tile,
+                                                        offset_functor,
+                                                        gpu_batch_row_boundaries.data(),
+                                                        dev_output_nm.data(),
+                                                        column_info.column_starts.back(),
+                                                        dev_validity_tile_infos,
+                                                        child.data<int8_t>());
+
+    std::vector<device_uvector<size_type>> string_col_offsets;
+    std::vector<rmm::device_uvector<char>> string_data_cols;
+    std::vector<size_type*> string_col_offset_ptrs;
+    std::vector<char*> string_data_col_ptrs;
+    for (auto& col_string_lengths : string_lengths) {
+      device_uvector<size_type> output_string_offsets(num_rows + 1, stream, mr);
+      auto tmp = cuda::proclaim_return_type<int32_t>(
+        [num_rows, col_string_lengths] __device__(auto const& i) {
+          return i < num_rows ? col_string_lengths[i] : 0;
+        });
+      auto bounded_iter = cudf::detail::make_counting_transform_iterator(0, tmp);
+      thrust::exclusive_scan(rmm::exec_policy(stream),
+                             bounded_iter,
+                             bounded_iter + num_rows + 1,
+                             output_string_offsets.begin());
+
+      // allocate destination string column
+      rmm::device_uvector<char> string_data(
+        output_string_offsets.element(num_rows, stream), stream, mr);
+
+      string_col_offset_ptrs.push_back(output_string_offsets.data());
+      string_data_col_ptrs.push_back(string_data.data());
+      string_col_offsets.push_back(std::move(output_string_offsets));
+      string_data_cols.push_back(std::move(string_data));
+    }
+    auto dev_string_col_offsets = make_device_uvector_async(
+      string_col_offset_ptrs, stream, rmm::mr::get_current_device_resource());
+    auto dev_string_data_cols = make_device_uvector_async(
+      string_data_col_ptrs, stream, rmm::mr::get_current_device_resource());
+
+    dim3 const string_blocks(
+      std::min(std::max(MIN_STRING_BLOCKS, num_rows / NUM_STRING_ROWS_PER_BLOCK_FROM_ROWS),
+               MAX_STRING_BLOCKS));
+
+    detail::copy_strings_from_rows<<<string_blocks,
+                                     NUM_WARPS_IN_BLOCK * cudf::detail::warp_size,
+                                     0,
+                                     stream.value()>>>(
+      offset_functor,
+      dev_string_row_offsets.data(),
+      dev_string_lengths.data(),
+      dev_string_col_offsets.data(),
+      dev_string_data_cols.data(),
+      child.data<int8_t>(),
+      num_rows,
+      static_cast<cudf::size_type>(string_col_offsets.size()));
+
+    // merge strings back into output_columns
+    int string_idx = 0;
+    for (int i = 0; i < static_cast<int>(schema.size()); ++i) {
+      if (schema[i].id() == type_id::STRING) {
+        // stuff real string column
+        auto string_data = string_row_offset_columns[string_idx].release()->release();
+        output_columns[i] =
+          make_strings_column(num_rows,
+                              std::make_unique<cudf::column>(
+                                std::move(string_col_offsets[string_idx]), rmm::device_buffer{}, 0),
+                              string_data_cols[string_idx].release(),
+                              0,
+                              std::move(*string_data.null_mask.release()));
+        // Null count set to 0, temporarily. Will be fixed up before return.
+        string_idx++;
+      }
+    }
+  }
+
+  // Set null counts, because output_columns are modified via mutable-view,
+  // in the kernel above.
+  // TODO(future): Consider setting null count in the kernel itself.
+  fixup_null_counts(output_columns, stream);
+
+  return std::make_unique<table>(std::move(output_columns));
+}
+
+std::unique_ptr<table> convert_from_rows_fixed_width_optimized(lists_column_view const& input,
+                                                               std::vector<data_type> const& schema,
+                                                               rmm::cuda_stream_view stream,
+                                                               rmm::mr::device_memory_resource* mr)
+{
+  // verify that the types are what we expect
+  column_view child    = input.child();
+  auto const list_type = child.type().id();
+  CUDF_EXPECTS(list_type == type_id::INT8 || list_type == type_id::UINT8,
+               "Only a list of bytes is supported as input");
+
+  auto const num_columns = schema.size();
+
+  if (detail::are_all_fixed_width(schema)) {
+    std::vector<size_type> column_start;
+    std::vector<size_type> column_size;
+
+    auto const num_rows     = input.parent().size();
+    auto const size_per_row = detail::compute_fixed_width_layout(schema, column_start, column_size);
+
+    // Ideally we would check that the offsets are all the same, etc. but for now this is probably
+    // fine
+    CUDF_EXPECTS(size_per_row * num_rows == child.size(),
+                 "The layout of the data appears to be off");
+    auto dev_column_start =
+      make_device_uvector_async(column_start, stream, rmm::mr::get_current_device_resource());
+    auto dev_column_size =
+      make_device_uvector_async(column_size, stream, rmm::mr::get_current_device_resource());
+
+    // Allocate the columns we are going to write into
+    std::vector<std::unique_ptr<column>> output_columns;
+    std::vector<int8_t*> output_data;
+    std::vector<bitmask_type*> output_nm;
+    for (int i = 0; i < static_cast<int>(num_columns); i++) {
+      auto column =
+        make_fixed_width_column(schema[i], num_rows, mask_state::UNINITIALIZED, stream, mr);
+      auto mut = column->mutable_view();
+      output_data.emplace_back(mut.data<int8_t>());
+      output_nm.emplace_back(mut.null_mask());
+      output_columns.emplace_back(std::move(column));
+    }
+
+    auto dev_output_data = make_device_uvector_async(output_data, stream, mr);
+    auto dev_output_nm   = make_device_uvector_async(output_nm, stream, mr);
+
+    dim3 blocks;
+    dim3 threads;
+    int shared_size =
+      detail::calc_fixed_width_kernel_dims(num_columns, num_rows, size_per_row, blocks, threads);
+
+    detail::copy_from_rows_fixed_width_optimized<<<blocks, threads, shared_size, stream.value()>>>(
+      num_rows,
+      num_columns,
+      size_per_row,
+      dev_column_start.data(),
+      dev_column_size.data(),
+      dev_output_data.data(),
+      dev_output_nm.data(),
+      child.data<int8_t>());
+
+    // Set null counts, because output_columns are modified via mutable-view,
+    // in the kernel above.
+    // TODO(future): Consider setting null count in the kernel itself.
+    fixup_null_counts(output_columns, stream);
+
+    return std::make_unique<table>(std::move(output_columns));
+  } else {
+    CUDF_FAIL("Only fixed width types are currently supported");
+  }
+}
+
+}  // namespace spark_rapids_jni
diff --git a/src/main/cpp/src/row_conversion.hpp b/src/main/cpp/src/row_conversion.hpp
new file mode 100644
index 0000000000..a5abd5b1bd
--- /dev/null
+++ b/src/main/cpp/src/row_conversion.hpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cudf/lists/lists_column_view.hpp>
+#include <cudf/table/table_view.hpp>
+#include <cudf/utilities/default_stream.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+
+#include <memory>
+
+namespace spark_rapids_jni {
+
+std::vector<std::unique_ptr<cudf::column>> convert_to_rows_fixed_width_optimized(
+  cudf::table_view const& tbl,
+  // TODO need something for validity
+  rmm::cuda_stream_view stream        = cudf::get_default_stream(),
+  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+
+std::vector<std::unique_ptr<cudf::column>> convert_to_rows(
+  cudf::table_view const& tbl,
+  // TODO need something for validity
+  rmm::cuda_stream_view stream        = cudf::get_default_stream(),
+  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+
+std::unique_ptr<cudf::table> convert_from_rows_fixed_width_optimized(
+  cudf::lists_column_view const& input,
+  std::vector<cudf::data_type> const& schema,
+  rmm::cuda_stream_view stream        = cudf::get_default_stream(),
+  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+
+std::unique_ptr<cudf::table> convert_from_rows(
+  cudf::lists_column_view const& input,
+  std::vector<cudf::data_type> const& schema,
+  rmm::cuda_stream_view stream        = cudf::get_default_stream(),
+  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+
+}  // namespace spark_rapids_jni
diff --git a/src/main/cpp/tests/CMakeLists.txt b/src/main/cpp/tests/CMakeLists.txt
index 617df6dfde..55a7b7a887 100644
--- a/src/main/cpp/tests/CMakeLists.txt
+++ b/src/main/cpp/tests/CMakeLists.txt
@@ -1,5 +1,5 @@
 #=============================================================================
-# Copyright (c) 2022-2023, NVIDIA CORPORATION.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -60,6 +60,9 @@ ConfigureTest(CAST_FLOAT_TO_STRING
 ConfigureTest(DATETIME_REBASE
     datetime_rebase.cpp)
 
+ConfigureTest(ROW_CONVERSION
+    row_conversion.cpp)
+
 ConfigureTest(HASH
     hash.cpp)
 
diff --git a/src/main/cpp/tests/row_conversion.cpp b/src/main/cpp/tests/row_conversion.cpp
new file mode 100644
index 0000000000..7a0565def9
--- /dev/null
+++ b/src/main/cpp/tests/row_conversion.cpp
@@ -0,0 +1,1029 @@
+/*
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cudf_test/base_fixture.hpp>
+#include <cudf_test/column_utilities.hpp>
+#include <cudf_test/column_wrapper.hpp>
+#include <cudf_test/table_utilities.hpp>
+
+#include <cudf/column/column_view.hpp>
+#include <cudf/detail/iterator.cuh>
+#include <cudf/lists/lists_column_view.hpp>
+#include <cudf/types.hpp>
+
+#include <row_conversion.hpp>
+
+#include <limits>
+#include <random>
+
+struct ColumnToRowTests : public cudf::test::BaseFixture {};
+struct RowToColumnTests : public cudf::test::BaseFixture {};
+
+TEST_F(ColumnToRowTests, Single)
+{
+  cudf::test::fixed_width_column_wrapper<int32_t> a({-1});
+  cudf::table_view in(std::vector<cudf::column_view>{a});
+  std::vector<cudf::data_type> schema = {cudf::data_type{cudf::type_id::INT32}};
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*new_rows[i]), schema);
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, SimpleString)
+{
+  cudf::test::fixed_width_column_wrapper<int32_t> a({-1, 0, 1, 0, -1});
+  cudf::test::strings_column_wrapper b(
+    {"hello", "world", "this is a really long string to generate a longer row", "dlrow", "olleh"});
+  cudf::table_view in(std::vector<cudf::column_view>{a, b});
+  std::vector<cudf::data_type> schema = {cudf::data_type{cudf::type_id::INT32}};
+
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(new_rows[0]->size(), 5);
+}
+
+TEST_F(ColumnToRowTests, DoubleString)
+{
+  cudf::test::strings_column_wrapper a(
+    {"hello", "world", "this is a really long string to generate a longer row", "dlrow", "olleh"});
+  cudf::test::fixed_width_column_wrapper<int32_t> b({0, 1, 2, 3, 4});
+  cudf::test::strings_column_wrapper c({"world",
+                                        "hello",
+                                        "this string isn't as long",
+                                        "this one isn't so short though when you think about it",
+                                        "dlrow"});
+  cudf::table_view in(std::vector<cudf::column_view>{a, b, c});
+
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(new_rows[0]->size(), 5);
+}
+
+TEST_F(ColumnToRowTests, BigStrings)
+{
+  char const* TEST_STRINGS[] = {
+    "These",
+    "are",
+    "the",
+    "test",
+    "strings",
+    "that",
+    "we",
+    "have",
+    "some are really long",
+    "and some are kinda short",
+    "They are all over on purpose with different sizes for the strings in order to test the code "
+    "on all different lengths of strings",
+    "a",
+    "good test",
+    "is required to produce reasonable confidence that this is working"};
+  auto num_generator =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  auto string_generator =
+    cudf::detail::make_counting_transform_iterator(0, [&](auto i) -> char const* {
+      return TEST_STRINGS[rand() % (sizeof(TEST_STRINGS) / sizeof(TEST_STRINGS[0]))];
+    });
+
+  auto const num_rows = 50;
+  auto const num_cols = 50;
+  std::vector<cudf::data_type> schema;
+
+  std::vector<cudf::test::detail::column_wrapper> cols;
+  std::vector<cudf::column_view> views;
+
+  for (auto col = 0; col < num_cols; ++col) {
+    if (rand() % 2) {
+      cols.emplace_back(
+        cudf::test::fixed_width_column_wrapper<int32_t>(num_generator, num_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::data_type{cudf::type_id::INT32});
+    } else {
+      cols.emplace_back(
+        cudf::test::strings_column_wrapper(string_generator, string_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::type_id::STRING);
+    }
+  }
+
+  cudf::table_view in(views);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(new_rows[0]->size(), num_rows);
+}
+
+TEST_F(ColumnToRowTests, ManyStrings)
+{
+  char const* TEST_STRINGS[] = {
+    "These",
+    "are",
+    "the",
+    "test",
+    "strings",
+    "that",
+    "we",
+    "have",
+    "some are really long",
+    "and some are kinda short",
+    "They are all over on purpose with different sizes for the strings in order to test the code "
+    "on all different lengths of strings",
+    "a",
+    "good test",
+    "is required to produce reasonable confidence that this is working",
+    "some strings",
+    "are split into multiple strings",
+    "some strings have all their data",
+    "lots of choices of strings and sizes is sure to test the offset calculation code to ensure "
+    "that even a really long string ends up in the correct spot for the final destination allowing "
+    "for even crazy run-on sentences to be inserted into the data"};
+  auto num_generator =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  auto string_generator =
+    cudf::detail::make_counting_transform_iterator(0, [&](auto i) -> char const* {
+      return TEST_STRINGS[rand() % (sizeof(TEST_STRINGS) / sizeof(TEST_STRINGS[0]))];
+    });
+
+  auto const num_rows = 1'000'000;
+  auto const num_cols = 50;
+  std::vector<cudf::data_type> schema;
+
+  std::vector<cudf::test::detail::column_wrapper> cols;
+  std::vector<cudf::column_view> views;
+
+  for (auto col = 0; col < num_cols; ++col) {
+    if (rand() % 2) {
+      cols.emplace_back(
+        cudf::test::fixed_width_column_wrapper<int32_t>(num_generator, num_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::data_type{cudf::type_id::INT32});
+    } else {
+      cols.emplace_back(
+        cudf::test::strings_column_wrapper(string_generator, string_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::type_id::STRING);
+    }
+  }
+
+  cudf::table_view in(views);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(new_rows[0]->size(), num_rows);
+}
+
+TEST_F(ColumnToRowTests, Simple)
+{
+  cudf::test::fixed_width_column_wrapper<int32_t> a({-1, 0, 1});
+  cudf::table_view in(std::vector<cudf::column_view>{a});
+  std::vector<cudf::data_type> schema = {cudf::data_type{cudf::type_id::INT32}};
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, Tall)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  cudf::test::fixed_width_column_wrapper<int32_t> a(r, r + (size_t)4096);
+  cudf::table_view in(std::vector<cudf::column_view>{a});
+  std::vector<cudf::data_type> schema = {cudf::data_type{cudf::type_id::INT32}};
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, Wide)
+{
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  for (int i = 0; i < 256; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>({rand()}));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, SingleByteWide)
+{
+  std::vector<cudf::test::fixed_width_column_wrapper<int8_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  for (int i = 0; i < 256; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int8_t>({rand()}));
+    views.push_back(cols.back());
+
+    schema.push_back(cudf::data_type{cudf::type_id::INT8});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, Non2Power)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  constexpr auto num_rows = 6 * 1024 + 557;
+  for (int i = 0; i < 131; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    for (int j = 0; j < old_tbl->num_columns(); ++j) {
+      CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(old_tbl->get_column(j), new_tbl->get_column(j));
+    }
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, Big)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  // 28 columns of 1 million rows
+  constexpr auto num_rows = 1024 * 1024;
+  for (int i = 0; i < 28; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    for (int j = 0; j < old_tbl->num_columns(); ++j) {
+      CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(old_tbl->get_column(j), new_tbl->get_column(j));
+    }
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, Bigger)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  // 128 columns of 1 million rows
+  constexpr auto num_rows = 1024 * 1024;
+  for (int i = 0; i < 128; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    for (int j = 0; j < old_tbl->num_columns(); ++j) {
+      CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(old_tbl->get_column(j), new_tbl->get_column(j));
+    }
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(ColumnToRowTests, Biggest)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  // 128 columns of 2 million rows
+  constexpr auto num_rows = 2 * 1024 * 1024;
+  for (int i = 0; i < 128; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  EXPECT_EQ(old_rows.size(), new_rows.size());
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    for (int j = 0; j < old_tbl->num_columns(); ++j) {
+      CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(old_tbl->get_column(j), new_tbl->get_column(j));
+    }
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Single)
+{
+  cudf::test::fixed_width_column_wrapper<int32_t> a({-1});
+  cudf::table_view in(std::vector<cudf::column_view>{a});
+
+  auto old_rows = spark_rapids_jni::convert_to_rows(in);
+  std::vector<cudf::data_type> schema{cudf::data_type{cudf::type_id::INT32}};
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Simple)
+{
+  cudf::test::fixed_width_column_wrapper<int32_t> a({-1, 0, 1});
+  cudf::table_view in(std::vector<cudf::column_view>{a});
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  std::vector<cudf::data_type> schema{cudf::data_type{cudf::type_id::INT32}};
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Tall)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  cudf::test::fixed_width_column_wrapper<int32_t> a(r, r + (size_t)4096);
+  cudf::table_view in(std::vector<cudf::column_view>{a});
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  std::vector<cudf::data_type> schema;
+  schema.reserve(in.num_columns());
+  for (auto col = in.begin(); col < in.end(); ++col) {
+    schema.push_back(col->type());
+  }
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Wide)
+{
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+
+  for (int i = 0; i < 256; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>({i}));  // rand()}));
+    views.push_back(cols.back());
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  std::vector<cudf::data_type> schema;
+  schema.reserve(in.num_columns());
+  for (auto col = in.begin(); col < in.end(); ++col) {
+    schema.push_back(col->type());
+  }
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, SingleByteWide)
+{
+  std::vector<cudf::test::fixed_width_column_wrapper<int8_t>> cols;
+  std::vector<cudf::column_view> views;
+
+  for (int i = 0; i < 256; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int8_t>({rand()}));
+    views.push_back(cols.back());
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  std::vector<cudf::data_type> schema;
+  schema.reserve(in.num_columns());
+  for (auto col = in.begin(); col < in.end(); ++col) {
+    schema.push_back(col->type());
+  }
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, AllTypes)
+{
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema{cudf::data_type{cudf::type_id::INT64},
+                                      cudf::data_type{cudf::type_id::FLOAT64},
+                                      cudf::data_type{cudf::type_id::INT8},
+                                      cudf::data_type{cudf::type_id::BOOL8},
+                                      cudf::data_type{cudf::type_id::FLOAT32},
+                                      cudf::data_type{cudf::type_id::INT8},
+                                      cudf::data_type{cudf::type_id::INT32},
+                                      cudf::data_type{cudf::type_id::INT64}};
+
+  cudf::test::fixed_width_column_wrapper<int64_t> c0({3, 9, 4, 2, 20, 0}, {1, 1, 1, 1, 1, 0});
+  cudf::test::fixed_width_column_wrapper<double> c1({5.0, 9.5, 0.9, 7.23, 2.8, 0.0},
+                                                    {1, 1, 1, 1, 1, 0});
+  cudf::test::fixed_width_column_wrapper<int8_t> c2({5, 1, 0, 2, 7, 0}, {1, 1, 1, 1, 1, 0});
+  cudf::test::fixed_width_column_wrapper<bool> c3({true, false, false, true, false, false},
+                                                  {1, 1, 1, 1, 1, 0});
+  cudf::test::fixed_width_column_wrapper<float> c4({1.0f, 3.5f, 5.9f, 7.1f, 9.8f, 0.0f},
+                                                   {1, 1, 1, 1, 1, 0});
+  cudf::test::fixed_width_column_wrapper<int8_t> c5({2, 3, 4, 5, 9, 0}, {1, 1, 1, 1, 1, 0});
+  cudf::test::fixed_point_column_wrapper<int32_t> c6(
+    {-300, 500, 950, 90, 723, 0}, {1, 1, 1, 1, 1, 1, 1, 0}, numeric::scale_type{-2});
+  cudf::test::fixed_point_column_wrapper<int64_t> c7(
+    {-80, 30, 90, 20, 200, 0}, {1, 1, 1, 1, 1, 1, 0}, numeric::scale_type{-1});
+
+  cudf::table_view in({c0, c1, c2, c3, c4, c5, c6, c7});
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*new_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, AllTypesLarge)
+{
+  std::vector<cudf::column> cols;
+  std::vector<cudf::data_type> schema{};
+
+  // 15 columns of each type with 1 million entries
+  constexpr int num_rows{1024 * 1024 * 1};
+
+  std::default_random_engine re;
+  std::uniform_real_distribution<double> rand_double(std::numeric_limits<double>::min(),
+                                                     std::numeric_limits<double>::max());
+  std::uniform_int_distribution<int64_t> rand_int64(std::numeric_limits<int64_t>::min(),
+                                                    std::numeric_limits<int64_t>::max());
+  auto r = cudf::detail::make_counting_transform_iterator(
+    0, [&](auto i) -> int64_t { return rand_int64(re); });
+  auto d = cudf::detail::make_counting_transform_iterator(
+    0, [&](auto i) -> double { return rand_double(re); });
+
+  auto all_valid  = cudf::detail::make_counting_transform_iterator(0, [](auto i) { return 1; });
+  auto none_valid = cudf::detail::make_counting_transform_iterator(0, [](auto i) { return 0; });
+  auto most_valid = cudf::detail::make_counting_transform_iterator(
+    0, [](auto i) { return rand() % 2 == 0 ? 0 : 1; });
+  auto few_valid = cudf::detail::make_counting_transform_iterator(
+    0, [](auto i) { return rand() % 13 == 0 ? 1 : 0; });
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(*cudf::test::fixed_width_column_wrapper<int8_t>(r, r + num_rows, all_valid)
+                      .release()
+                      .release());
+    schema.push_back(cudf::data_type{cudf::type_id::INT8});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(*cudf::test::fixed_width_column_wrapper<int16_t>(r, r + num_rows, few_valid)
+                      .release()
+                      .release());
+    schema.push_back(cudf::data_type{cudf::type_id::INT16});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    if (i < 5) {
+      cols.push_back(*cudf::test::fixed_width_column_wrapper<int32_t>(r, r + num_rows, few_valid)
+                        .release()
+                        .release());
+    } else {
+      cols.push_back(*cudf::test::fixed_width_column_wrapper<int32_t>(r, r + num_rows, none_valid)
+                        .release()
+                        .release());
+    }
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(*cudf::test::fixed_width_column_wrapper<float>(d, d + num_rows, most_valid)
+                      .release()
+                      .release());
+    schema.push_back(cudf::data_type{cudf::type_id::FLOAT32});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(*cudf::test::fixed_width_column_wrapper<double>(d, d + num_rows, most_valid)
+                      .release()
+                      .release());
+    schema.push_back(cudf::data_type{cudf::type_id::FLOAT64});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(*cudf::test::fixed_width_column_wrapper<bool>(r, r + num_rows, few_valid)
+                      .release()
+                      .release());
+    schema.push_back(cudf::data_type{cudf::type_id::BOOL8});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(
+      *cudf::test::fixed_width_column_wrapper<cudf::timestamp_ms, cudf::timestamp_ms::rep>(
+         r, r + num_rows, all_valid)
+         .release()
+         .release());
+    schema.push_back(cudf::data_type{cudf::type_id::TIMESTAMP_MILLISECONDS});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(
+      *cudf::test::fixed_width_column_wrapper<cudf::timestamp_D, cudf::timestamp_D::rep>(
+         r, r + num_rows, most_valid)
+         .release()
+         .release());
+    schema.push_back(cudf::data_type{cudf::type_id::TIMESTAMP_DAYS});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(*cudf::test::fixed_point_column_wrapper<int32_t>(
+                      r, r + num_rows, all_valid, numeric::scale_type{-2})
+                      .release()
+                      .release());
+    schema.push_back(cudf::data_type{cudf::type_id::DECIMAL32});
+  }
+
+  for (int i = 0; i < 15; ++i) {
+    cols.push_back(*cudf::test::fixed_point_column_wrapper<int64_t>(
+                      r, r + num_rows, most_valid, numeric::scale_type{-1})
+                      .release()
+                      .release());
+    schema.push_back(cudf::data_type{cudf::type_id::DECIMAL64});
+  }
+
+  std::vector<cudf::column_view> views(cols.begin(), cols.end());
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*new_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Non2Power)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  constexpr auto num_rows = 6 * 1024 + 557;
+  for (int i = 0; i < 131; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Big)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  // 28 columns of 1 million rows
+  constexpr auto num_rows = 1024 * 1024;
+  for (int i = 0; i < 28; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Bigger)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  // 128 columns of 1 million rows
+  constexpr auto num_rows = 1024 * 1024;
+  for (int i = 0; i < 128; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*old_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, Biggest)
+{
+  auto r =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  std::vector<cudf::test::fixed_width_column_wrapper<int32_t>> cols;
+  std::vector<cudf::column_view> views;
+  std::vector<cudf::data_type> schema;
+
+  // 128 columns of 2 million rows
+  constexpr auto num_rows = 2 * 1024 * 1024;
+  for (int i = 0; i < 128; ++i) {
+    cols.push_back(cudf::test::fixed_width_column_wrapper<int32_t>(r + num_rows * i,
+                                                                   r + num_rows * i + num_rows));
+    views.push_back(cols.back());
+    schema.push_back(cudf::data_type{cudf::type_id::INT32});
+  }
+  cudf::table_view in(views);
+
+  auto old_rows = spark_rapids_jni::convert_to_rows_fixed_width_optimized(in);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  for (uint i = 0; i < old_rows.size(); ++i) {
+    auto old_tbl = spark_rapids_jni::convert_from_rows_fixed_width_optimized(
+      cudf::lists_column_view(*old_rows[i]), schema);
+    auto new_tbl =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*new_rows[i]), schema);
+
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*old_tbl, *new_tbl);
+  }
+}
+
+TEST_F(RowToColumnTests, SimpleString)
+{
+  cudf::test::fixed_width_column_wrapper<int32_t> a({-1, 0, 1, 0, -1});
+  cudf::test::strings_column_wrapper b(
+    {"hello", "world", "this is a really long string to generate a longer row", "dlrow", "olleh"});
+  cudf::table_view in(std::vector<cudf::column_view>{a, b});
+  std::vector<cudf::data_type> schema = {cudf::data_type{cudf::type_id::INT32},
+                                         cudf::data_type{cudf::type_id::STRING}};
+
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+  EXPECT_EQ(new_rows.size(), 1);
+  for (auto& row : new_rows) {
+    auto new_cols = spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*row), schema);
+    EXPECT_EQ(row->size(), 5);
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(in, *new_cols);
+  }
+}
+
+TEST_F(RowToColumnTests, DoubleString)
+{
+  cudf::test::strings_column_wrapper a(
+    {"hello", "world", "this is a really long string to generate a longer row", "dlrow", "olleh"});
+  cudf::test::fixed_width_column_wrapper<int32_t> b({0, 1, 2, 3, 4});
+  cudf::test::strings_column_wrapper c({"world",
+                                        "hello",
+                                        "this string isn't as long",
+                                        "this one isn't so short though when you think about it",
+                                        "dlrow"});
+  cudf::table_view in(std::vector<cudf::column_view>{a, b, c});
+  std::vector<cudf::data_type> schema = {cudf::data_type{cudf::type_id::STRING},
+                                         cudf::data_type{cudf::type_id::INT32},
+                                         cudf::data_type{cudf::type_id::STRING}};
+
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  for (uint i = 0; i < new_rows.size(); ++i) {
+    auto new_cols =
+      spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*new_rows[i]), schema);
+
+    EXPECT_EQ(new_rows[0]->size(), 5);
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(in, *new_cols);
+  }
+}
+
+TEST_F(RowToColumnTests, BigStrings)
+{
+  char const* TEST_STRINGS[] = {
+    "These",
+    "are",
+    "the",
+    "test",
+    "strings",
+    "that",
+    "we",
+    "have",
+    "some are really long",
+    "and some are kinda short",
+    "They are all over on purpose with different sizes for the strings in order to test the code "
+    "on all different lengths of strings",
+    "a",
+    "good test",
+    "is required to produce reasonable confidence that this is working"};
+  auto num_generator =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  auto string_generator =
+    cudf::detail::make_counting_transform_iterator(0, [&](auto i) -> char const* {
+      return TEST_STRINGS[rand() % (sizeof(TEST_STRINGS) / sizeof(TEST_STRINGS[0]))];
+    });
+
+  auto const num_rows = 50;
+  auto const num_cols = 50;
+  std::vector<cudf::data_type> schema;
+
+  std::vector<cudf::test::detail::column_wrapper> cols;
+  std::vector<cudf::column_view> views;
+
+  for (auto col = 0; col < num_cols; ++col) {
+    if (rand() % 2) {
+      cols.emplace_back(
+        cudf::test::fixed_width_column_wrapper<int32_t>(num_generator, num_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::data_type{cudf::type_id::INT32});
+    } else {
+      cols.emplace_back(
+        cudf::test::strings_column_wrapper(string_generator, string_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::type_id::STRING);
+    }
+  }
+
+  cudf::table_view in(views);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  for (auto& i : new_rows) {
+    auto new_cols = spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*i), schema);
+
+    auto in_view = cudf::slice(in, {0, new_cols->num_rows()});
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(in_view[0], *new_cols);
+  }
+}
+
+TEST_F(RowToColumnTests, ManyStrings)
+{
+  // The sizing of this test is very sensitive to the state of the random number generator,
+  // i.e., depending on the order of execution, the number of times the largest string is
+  // selected will lead to out-of-memory exceptions. Seeding the RNG here helps prevent that.
+  srand(1);
+  char const* TEST_STRINGS[] = {
+    "These",
+    "are",
+    "the",
+    "test",
+    "strings",
+    "that",
+    "we",
+    "have",
+    "some are really long",
+    "and some are kinda short",
+    "They are all over on purpose with different sizes for the strings in order to test the code "
+    "on all different lengths of strings",
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine "
+    "this string is the longest string because it is duplicated more than you can imagine ",
+    "a",
+    "good test",
+    "is required to produce reasonable confidence that this is working",
+    "some strings",
+    "are split into multiple strings",
+    "some strings have all their data",
+    "lots of choices of strings and sizes is sure to test the offset calculation code to ensure "
+    "that even a really long string ends up in the correct spot for the final destination allowing "
+    "for even crazy run-on sentences to be inserted into the data"};
+  auto num_generator =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) -> int32_t { return rand(); });
+  auto string_generator =
+    cudf::detail::make_counting_transform_iterator(0, [&](auto i) -> char const* {
+      return TEST_STRINGS[rand() % (sizeof(TEST_STRINGS) / sizeof(TEST_STRINGS[0]))];
+    });
+
+  auto const num_rows = 300'000;
+  auto const num_cols = 50;
+  std::vector<cudf::data_type> schema;
+
+  std::vector<cudf::test::detail::column_wrapper> cols;
+  std::vector<cudf::column_view> views;
+
+  for (auto col = 0; col < num_cols; ++col) {
+    if (rand() % 2) {
+      cols.emplace_back(
+        cudf::test::fixed_width_column_wrapper<int32_t>(num_generator, num_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::data_type{cudf::type_id::INT32});
+    } else {
+      cols.emplace_back(
+        cudf::test::strings_column_wrapper(string_generator, string_generator + num_rows));
+      views.push_back(cols.back());
+      schema.emplace_back(cudf::type_id::STRING);
+    }
+  }
+
+  cudf::table_view in(views);
+  auto new_rows = spark_rapids_jni::convert_to_rows(in);
+
+  for (auto& i : new_rows) {
+    auto new_cols = spark_rapids_jni::convert_from_rows(cudf::lists_column_view(*i), schema);
+
+    auto in_view = cudf::slice(in, {0, new_cols->num_rows()});
+    CUDF_TEST_EXPECT_TABLES_EQUIVALENT(in_view[0], *new_cols);
+  }
+}

From b201eaf65dfaa141e17d0dbb3ac2f8b7d6404f0e Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 7 Mar 2024 02:27:50 +0800
Subject: [PATCH 083/132] [submodule-sync] bot-submodule-sync-branch-24.04 to
 branch-24.04 [skip ci] [bot] (#1839)

* Update submodule cudf to e612a8aee5ba54f397b8d5be14201776bac9dd2d

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

* Update submodule cudf to dbf7236c4b30ee6f87223b728688cddf39453d14

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

* Update submodule cudf to bb0e4fdd6f4960d1d5125256dc147f28d83db560

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

---------

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 176f75b1da..bb0e4fdd6f 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 176f75b1da0559c024a62a98f13ff15491f18a95
+Subproject commit bb0e4fdd6f4960d1d5125256dc147f28d83db560

From bfff22d376ff245e1699a7ed85eeb72b9a994a14 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 7 Mar 2024 06:10:07 +0800
Subject: [PATCH 084/132] Update submodule cudf to
 eb8de186720a7edda90760cb189566df18146911 (#1841)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index bb0e4fdd6f..eb8de18672 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit bb0e4fdd6f4960d1d5125256dc147f28d83db560
+Subproject commit eb8de186720a7edda90760cb189566df18146911

From f5a894383e53c01aa9e317f73d298af6982b6af3 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 7 Mar 2024 11:38:26 +0800
Subject: [PATCH 085/132] Update submodule cudf to
 9678c900a484818b489b723e2568e7b7c0d0b090 (#1842)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index eb8de18672..9678c900a4 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit eb8de186720a7edda90760cb189566df18146911
+Subproject commit 9678c900a484818b489b723e2568e7b7c0d0b090

From 48befbfc7ce5f46a70903bab62ccfd33e29472ab Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 7 Mar 2024 18:19:33 +0800
Subject: [PATCH 086/132] Update submodule cudf to
 efae666bac226dc50c1c7b5d7f1145ee9a31fc66 (#1844)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 9678c900a4..efae666bac 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 9678c900a484818b489b723e2568e7b7c0d0b090
+Subproject commit efae666bac226dc50c1c7b5d7f1145ee9a31fc66

From ebc2c485636ed3fad9937d723ba33143e3945a62 Mon Sep 17 00:00:00 2001
From: Tim Liu <timl@nvidia.com>
Date: Thu, 7 Mar 2024 20:34:45 +0800
Subject: [PATCH 087/132] Move K8s cloud name into common lib for Jenkins CI
 (#1824)

Signed-off-by: Tim Liu <timl@nvidia.com>
---
 ci/Jenkinsfile.premerge | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ci/Jenkinsfile.premerge b/ci/Jenkinsfile.premerge
index 72ef595a37..ea9a1f5d78 100644
--- a/ci/Jenkinsfile.premerge
+++ b/ci/Jenkinsfile.premerge
@@ -42,7 +42,7 @@ pipeline {
     agent {
         kubernetes {
             label "premerge-init-${BUILD_TAG}"
-            cloud 'sc-ipp-blossom-prod'
+            cloud "${common.CLOUD_NAME}"
             yaml cpuImage
         }
     }
@@ -113,7 +113,7 @@ pipeline {
             agent {
                 kubernetes {
                     label "premerge-docker-${BUILD_TAG}"
-                    cloud 'sc-ipp-blossom-prod'
+                    cloud "${common.CLOUD_NAME}"
                     yaml pod.getDockerBuildYAML()
                     workspaceVolume persistentVolumeClaimWorkspaceVolume(claimName: "${PVC}", readOnly: false)
                     customWorkspace "${CUSTOM_WORKSPACE}"
@@ -200,7 +200,7 @@ git --no-pager diff --name-only HEAD \$BASE -- ${PREMERGE_DOCKERFILE} || true"""
             agent {
                 kubernetes {
                     label "premerge-ci-1-${BUILD_TAG}"
-                    cloud 'sc-ipp-blossom-prod'
+                    cloud "${common.CLOUD_NAME}"
                     yaml pod.getGPUYAML("${IMAGE_PREMERGE}", "${env.GPU_RESOURCE}", '8', '32Gi')
                     workspaceVolume persistentVolumeClaimWorkspaceVolume(claimName: "${PVC}", readOnly: false)
                     customWorkspace "${CUSTOM_WORKSPACE}"

From 0af4d0dfba5f703b4fa8060c6254a62a5009da41 Mon Sep 17 00:00:00 2001
From: Partho Sarthi <psarthi16@gmail.com>
Date: Thu, 7 Mar 2024 10:44:10 -0800
Subject: [PATCH 088/132] Append new authorized user to blossom-ci whitelist
 [skip ci] (#1845)

* Append new authorized user to blossom-ci
* Fix copyright

Signed-off-by: Partho Sarthi <psarthi@nvidia.com>
---
 .github/workflows/blossom-ci.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/blossom-ci.yml b/.github/workflows/blossom-ci.yml
index 8aa90b9ee6..5e4005462f 100644
--- a/.github/workflows/blossom-ci.yml
+++ b/.github/workflows/blossom-ci.yml
@@ -1,4 +1,4 @@
-# Copyright (c) 2022-2023, NVIDIA CORPORATION.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -65,6 +65,7 @@ jobs:
       NVnavkumar,\
       yinqingh,\
       thirtiseven,\
+      parthosa,\
       ', format('{0},', github.actor)) && github.event.comment.body == 'build'
     steps:
       - name: Check if comment is issued by authorized person

From 8f8aeedb8217cefd2ba3f23559ed561781f93267 Mon Sep 17 00:00:00 2001
From: Partho Sarthi <psarthi16@gmail.com>
Date: Thu, 7 Mar 2024 10:58:53 -0800
Subject: [PATCH 089/132] Add GPU architectures to the build-info file (#1840)

Add semicolon-separated list of target GPU archs as `gpu_architectures` version info property

---------
Signed-off-by: Partho Sarthi <psarth@nvidia.com>
---
 build/build-info | 7 +++++--
 pom.xml          | 2 ++
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/build/build-info b/build/build-info
index ff3836ff89..bc17cf3983 100755
--- a/build/build-info
+++ b/build/build-info
@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 
 #
-# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -20,18 +20,21 @@
 # Arguments:
 #   version  - The current version of the project
 #   git_path - The path to the repository
+#   libcudf_path - The path to the libcudf library
 set -e
 
 echo_build_properties() {
   version=$1
   git_path=$2
-  shift 2
+  libcudf_path=$3
+  shift 3
   echo version=$version
   echo user=$USER
   echo revision=$(cd "$git_path" && git rev-parse HEAD)
   echo branch=$(cd "$git_path" && git rev-parse --abbrev-ref HEAD)
   echo date=$(date -u +%Y-%m-%dT%H:%M:%SZ)
   echo url=$(cd "$git_path" && git config --get remote.origin.url)
+  echo gpu_architectures=$(cuobjdump "$libcudf_path" 2>/dev/null | awk -F_ '/arch =/ {print $2}' | sort -n -u | tr '\n' ';')
   for arg in "$@"; do
     echo $arg
   done
diff --git a/pom.xml b/pom.xml
index 14bfa4bd4a..f7a4fcd354 100644
--- a/pom.xml
+++ b/pom.xml
@@ -476,6 +476,7 @@
                   <arg value="${project.basedir}/build/build-info"/>
                   <arg value="${project.version}"/>
                   <arg value="${cudf.path}"/>
+                  <arg value="${libcudf.build.path}/libcudf.a"/>
                 </exec>
                 <exec executable="bash"
                       output="${project.build.directory}/extra-resources/spark-rapids-jni-version-info.properties"
@@ -483,6 +484,7 @@
                   <arg value="${project.basedir}/build/build-info"/>
                   <arg value="${project.version}"/>
                   <arg value="${project.basedir}"/>
+                  <arg value="${native.build.path}/libcudf.so"/>
                 </exec>
               </target>
             </configuration>

From 2ea234fb891bb4b8f3e09c44c0427317f2cc0c8d Mon Sep 17 00:00:00 2001
From: Gera Shegalov <gera@apache.org>
Date: Thu, 7 Mar 2024 11:11:12 -0800
Subject: [PATCH 090/132] Use whoami instead of $USER (#1843)

Use `whoami` to populate the `user` build info property.

Docker does not create the envrironment variable USER per
https://docs.docker.com/engine/reference/run/#environment-variables

Signed-off-by: Gera Shegalov <gera@apache.org>
---
 build/build-info | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build/build-info b/build/build-info
index bc17cf3983..ff824b2df9 100755
--- a/build/build-info
+++ b/build/build-info
@@ -29,7 +29,7 @@ echo_build_properties() {
   libcudf_path=$3
   shift 3
   echo version=$version
-  echo user=$USER
+  echo user=$(whoami)
   echo revision=$(cd "$git_path" && git rev-parse HEAD)
   echo branch=$(cd "$git_path" && git rev-parse --abbrev-ref HEAD)
   echo date=$(date -u +%Y-%m-%dT%H:%M:%SZ)

From 6cb7c2b4bb33727f1f9314f3f74e13e9273ef17c Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 8 Mar 2024 05:40:52 +0800
Subject: [PATCH 091/132] Update submodule cudf to
 abdca82e7f6d1a7386930a2e0d30f987b2f6a633 (#1846)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index efae666bac..abdca82e7f 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit efae666bac226dc50c1c7b5d7f1145ee9a31fc66
+Subproject commit abdca82e7f6d1a7386930a2e0d30f987b2f6a633

From c5c8c8b76a9650faeab55e64f1d2c0abb9c090a3 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 8 Mar 2024 11:31:10 +0800
Subject: [PATCH 092/132] Update submodule cudf to
 b909732cd2916b7adca82f4f90a6580e6a7dbd92 (#1849)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index abdca82e7f..b909732cd2 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit abdca82e7f6d1a7386930a2e0d30f987b2f6a633
+Subproject commit b909732cd2916b7adca82f4f90a6580e6a7dbd92

From 338cd01fcf9a1c07685dfbe1f534f2c15b4f9329 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 8 Mar 2024 17:27:27 +0800
Subject: [PATCH 093/132] Update submodule cudf to
 65fb21803bd39ddc5e57426d365d1c2d0fa5f357 (#1850)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index b909732cd2..65fb21803b 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit b909732cd2916b7adca82f4f90a6580e6a7dbd92
+Subproject commit 65fb21803bd39ddc5e57426d365d1c2d0fa5f357

From 297eecc1a8f43352507ce7a629dc34a6ead1e33b Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 8 Mar 2024 21:26:39 +0800
Subject: [PATCH 094/132] Update submodule cudf to
 2ebfc808a46bcabb893a1b8345749fc3dd954a96 (#1851)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 65fb21803b..2ebfc808a4 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 65fb21803bd39ddc5e57426d365d1c2d0fa5f357
+Subproject commit 2ebfc808a46bcabb893a1b8345749fc3dd954a96

From 763d79adc447346e503bd11b10b19a78954021f0 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Sat, 9 Mar 2024 05:33:46 +0800
Subject: [PATCH 095/132] Update submodule cudf to
 c9e54cfe20c030a3772d4179c750b4a3358c9ee1 (#1854)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 2ebfc808a4..c9e54cfe20 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 2ebfc808a46bcabb893a1b8345749fc3dd954a96
+Subproject commit c9e54cfe20c030a3772d4179c750b4a3358c9ee1

From c8b71a017442dff6bee0f1bca082af58935a674e Mon Sep 17 00:00:00 2001
From: MithunR <mythrocks@gmail.com>
Date: Sat, 9 Mar 2024 19:56:22 -0800
Subject: [PATCH 096/132] Remove deprecated `supports_streams()` (#1847)

Fixes #1814.

This change removes the override of `spark_resource_adaptor::supports_stream()`,
in light of https://github.com/rapidsai/rmm/issues/1389, which deprecated the
method.

Similar to https://github.com/rapidsai/cudf/pull/14857, this change removes
the deprecated override.

Signed-off-by: MithunR <mythrocks@gmail.com>
---
 src/main/cpp/src/SparkResourceAdaptorJni.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/main/cpp/src/SparkResourceAdaptorJni.cpp b/src/main/cpp/src/SparkResourceAdaptorJni.cpp
index 37836ca67e..b68cc16308 100644
--- a/src/main/cpp/src/SparkResourceAdaptorJni.cpp
+++ b/src/main/cpp/src/SparkResourceAdaptorJni.cpp
@@ -401,8 +401,6 @@ class spark_resource_adaptor final : public rmm::mr::device_memory_resource {
 
   rmm::mr::device_memory_resource* get_wrapped_resource() { return resource; }
 
-  bool supports_streams() const noexcept override { return resource->supports_streams(); }
-
   /**
    * Update the internal state so that a specific thread is dedicated to a task.
    * This may be called multiple times for a given thread and if the thread is already

From c71fdba1f0ab5bb39001c75c9a350613ef7ae2cc Mon Sep 17 00:00:00 2001
From: Bradley Dice <bdice@bradleydice.com>
Date: Mon, 11 Mar 2024 17:36:51 -0500
Subject: [PATCH 097/132] Use NVTX from GitHub. (#1859)

* Update submodule cudf to b08dd9bed15e60d86a561fc0cb47cdbc2428a09b

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

* Update submodule cudf to 6a03827a74aa820e4e9ad241b0bc0450ceb8c018

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

* Update submodule cudf to dfaa41c28e27f54500cf41e91958528c8f883319

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

* Use NVTX from GitHub.

---------

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
Co-authored-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 src/main/cpp/CMakeLists.txt | 4 ++++
 thirdparty/cudf             | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/main/cpp/CMakeLists.txt b/src/main/cpp/CMakeLists.txt
index 3baf384b1e..704a5a308b 100644
--- a/src/main/cpp/CMakeLists.txt
+++ b/src/main/cpp/CMakeLists.txt
@@ -94,6 +94,9 @@ include(cmake/Modules/ConfigureCUDA.cmake) # set other CUDA compilation flags
 # ##################################################################################################
 # * dependencies ----------------------------------------------------------------------------------
 
+# find NVTX
+include(${CUDF_DIR}/cpp/cmake/thirdparty/get_nvtx.cmake)
+
 # find CCCL
 include(${CUDF_DIR}/cpp/cmake/thirdparty/get_cccl.cmake)
 
@@ -224,6 +227,7 @@ target_link_libraries(
   -Wl,--whole-archive
     ${CUDFJNI_LIB}
     cudf::cudf
+    nvtx3-cpp
   -Wl,--no-whole-archive
     ${PARQUET_LIB}
     ${THRIFT_LIB}
diff --git a/thirdparty/cudf b/thirdparty/cudf
index c9e54cfe20..dfaa41c28e 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit c9e54cfe20c030a3772d4179c750b4a3358c9ee1
+Subproject commit dfaa41c28e27f54500cf41e91958528c8f883319

From 0ae2398408d3288a0f6a4e1c388c109e20a026b9 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 12 Mar 2024 07:35:06 +0800
Subject: [PATCH 098/132] [submodule-sync] bot-submodule-sync-branch-24.04 to
 branch-24.04 [skip ci] [bot] (#1855)

* Update submodule cudf to b08dd9bed15e60d86a561fc0cb47cdbc2428a09b

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

* Update submodule cudf to 6a03827a74aa820e4e9ad241b0bc0450ceb8c018

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

* Update submodule cudf to dfaa41c28e27f54500cf41e91958528c8f883319

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

* Update submodule cudf to 8ed3e20f3d800adde15c94799ac743ae52d251a6

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>

---------

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index dfaa41c28e..8ed3e20f3d 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit dfaa41c28e27f54500cf41e91958528c8f883319
+Subproject commit 8ed3e20f3d800adde15c94799ac743ae52d251a6

From 5f275224d16e0a0f56774f5519c33439af8a4a30 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 12 Mar 2024 10:28:01 +0800
Subject: [PATCH 099/132] Update submodule cudf to
 241825a7b4db1713f44d8c298e08364b1eea9a32 (#1860)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 8ed3e20f3d..241825a7b4 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 8ed3e20f3d800adde15c94799ac743ae52d251a6
+Subproject commit 241825a7b4db1713f44d8c298e08364b1eea9a32

From f076cdaaf116371aa14d1cc29d16547e8dd5e50c Mon Sep 17 00:00:00 2001
From: Tim Liu <timl@nvidia.com>
Date: Tue, 12 Mar 2024 22:45:37 +0800
Subject: [PATCH 100/132] Update to support checkout to the cudf release tag
 [skip ci] (#1853)

* Update to support checkout to the cudf release tag

Update ci/submodule-sync.sh to support pinning cudf submodule to the release tag,

then CI job can run the auto release leveraging this change.

Signed-off-by: Tim Liu <timl@nvidia.com>

* Update ci/submodule-sync.sh

Co-authored-by: Jason Lowe <jlowe@nvidia.com>

---------

Signed-off-by: Tim Liu <timl@nvidia.com>
Co-authored-by: Jason Lowe <jlowe@nvidia.com>
---
 ci/submodule-sync.sh | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/ci/submodule-sync.sh b/ci/submodule-sync.sh
index 2b8b186152..8822b3cf7b 100755
--- a/ci/submodule-sync.sh
+++ b/ci/submodule-sync.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-# Copyright (c) 2022-2023, NVIDIA CORPORATION. All rights reserved.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -49,8 +49,14 @@ else
   git merge origin/${REF}
 fi
 
-# sync up cudf from remote
-git submodule update --remote --merge
+# sync up cudf from remote, checkout to cudf release tag if CUDF_TAG is set
+if [ -n "$CUDF_TAG" ]; then
+  pushd thirdparty/cudf
+  git checkout tags/$CUDF_TAG
+  popd
+else
+  git submodule update --remote --merge
+fi
 cudf_sha=$(git -C thirdparty/cudf rev-parse HEAD)
 if [[ "${cudf_sha}" == "${cudf_prev_sha}" ]]; then
   echo "Submodule is up to date."
@@ -59,7 +65,7 @@ fi
 
 echo "Try update cudf submodule to ${cudf_sha}..."
 git add .
-git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${cudf_sha}"
+git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${CUDF_TAG:-$cudf_sha}"
 sha=$(git rev-parse HEAD)
 
 echo "Test against ${cudf_sha}..."

From b75077453dff0c451f40bd19e85e5b827d730844 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 13 Mar 2024 10:31:47 +0800
Subject: [PATCH 101/132] Update submodule cudf to
 a4e73a5d26c430f4607ddcd7e8c3704a602a19f3 (#1866)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 241825a7b4..a4e73a5d26 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 241825a7b4db1713f44d8c298e08364b1eea9a32
+Subproject commit a4e73a5d26c430f4607ddcd7e8c3704a602a19f3

From 5e1696f284739422ba0778b4c0d0a4072d0e8a28 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 13 Mar 2024 17:13:20 +0800
Subject: [PATCH 102/132] Update submodule cudf to
 39a365b119cc47cfbd0ce0b27b62956e9f394df3 (#1867)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index a4e73a5d26..39a365b119 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit a4e73a5d26c430f4607ddcd7e8c3704a602a19f3
+Subproject commit 39a365b119cc47cfbd0ce0b27b62956e9f394df3

From 4b7d200c8df504acdcb2b0e1fc9fd845b5e1c6c3 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 13 Mar 2024 22:30:12 +0800
Subject: [PATCH 103/132] Update submodule cudf to
 2020ddd172e59d254efcfa5841a4401765bdf393 (#1869)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 39a365b119..2020ddd172 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 39a365b119cc47cfbd0ce0b27b62956e9f394df3
+Subproject commit 2020ddd172e59d254efcfa5841a4401765bdf393

From 010433ed1891b4b506319999f6b7274ac8bd5f38 Mon Sep 17 00:00:00 2001
From: Gera Shegalov <gera@apache.org>
Date: Wed, 13 Mar 2024 13:07:31 -0700
Subject: [PATCH 104/132] Improve build-info script (#1858)

When running the script outside Docker on the host without CUDA runtime I noticed that it may succeed while generating a corrupt properties file.

```
version=24.04.0-SNAPSHOT
user=user1
revision=d9ec683518b78fb3a52272b324f2184f19381318
branch=branchXY
date=2024-03-11T18:01:51Z
url=git@github.com:NVIDIA/spark-rapids-jni
/home/user1/gits/NVIDIA/spark-rapids-jni/build/build-info: line 53: cuobjdump: command not found
```

This PR improves the script as follows:

- Enable pipefail option to make sure that errors in the pipe are detected by bash
- Separate assignment gpu_architectures to avoid masking the subshell failure by `echo`
- Since awk is symlinked to gawk in the Docker image, we can implement the entire logic for gpu archs in gawk
- Removing the trailing ';' from the list of archs

**Testing**

```
~/gits/NVIDIA/spark-rapids-jni$ $PWD/build/build-info 24.04.0-SNAPSHOT $PWD $PWD/target/libcudf-install/lib64/libcudf.a
version=24.04.0-SNAPSHOT
user=user1
revision=d9ec683518b78fb3a52272b324f2184f19381318
branch=fixTrailingSemicolon
date=2024-03-11T21:18:48Z
url=git@github.com:NVIDIA/spark-rapids-jni
/home/user1/gits/NVIDIA/spark-rapids-jni/build/build-info: line 53: cuobjdump: command not found
~/gits/NVIDIA/spark-rapids-jni$ echo $?
127
```

```
./build/run-in-docker $PWD/build/build-info 24.04.0-SNAPSHOT $PWD $PWD/target/libcudf-install/lib64/libcudf.a
version=24.04.0-SNAPSHOT
user=user1
revision=d9ec683518b78fb3a52272b324f2184f19381318
branch=fixTrailingSemicolon
date=2024-03-11T18:27:31Z
url=git@github.com:NVIDIA/spark-rapids-jni
gpu_architectures=75;86
```

Signed-off-by: Gera Shegalov <gera@apache.org>
Co-authored-by: Jason Lowe <jlowe@nvidia.com>
---
 build/build-info | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/build/build-info b/build/build-info
index ff824b2df9..bb7b81e1b6 100755
--- a/build/build-info
+++ b/build/build-info
@@ -22,6 +22,7 @@
 #   git_path - The path to the repository
 #   libcudf_path - The path to the libcudf library
 set -e
+set -o pipefail
 
 echo_build_properties() {
   version=$1
@@ -34,7 +35,27 @@ echo_build_properties() {
   echo branch=$(cd "$git_path" && git rev-parse --abbrev-ref HEAD)
   echo date=$(date -u +%Y-%m-%dT%H:%M:%SZ)
   echo url=$(cd "$git_path" && git config --get remote.origin.url)
-  echo gpu_architectures=$(cuobjdump "$libcudf_path" 2>/dev/null | awk -F_ '/arch =/ {print $2}' | sort -n -u | tr '\n' ';')
+  gpu_architectures=$(
+    cuobjdump "$libcudf_path" | gawk '
+      match($0, /arch = sm_([0-9]+)/, tmp) {
+        arch[tmp[1]] = 1
+      }
+
+      END {
+        n = asorti(arch)
+        if (n == 0) {
+          print "ERROR: No fatbin ELF / PTX code sections found" > "/dev/stderr"
+          exit(1)
+        }
+        s = arch[1]
+        for (i = 2; i <= n; i++) {
+          s = s ";" arch[i]
+        }
+        print s
+      }
+    '
+  )
+  echo "gpu_architectures=$gpu_architectures"
   for arg in "$@"; do
     echo $arg
   done

From a607db70e331460761ece5bd24bbcfeb0354805c Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 14 Mar 2024 04:30:41 +0800
Subject: [PATCH 105/132] Update submodule cudf to
 33a201d08f518831b612aced8f4be1054a6df2fb (#1870)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 2020ddd172..33a201d08f 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 2020ddd172e59d254efcfa5841a4401765bdf393
+Subproject commit 33a201d08f518831b612aced8f4be1054a6df2fb

From ba61352d615a0f46a6f2d07ef745ff09e4797285 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 14 Mar 2024 10:30:56 +0800
Subject: [PATCH 106/132] Update submodule cudf to
 85f41dfdb606664cd8bb256dff943bf81aa8816d (#1871)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 33a201d08f..85f41dfdb6 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 33a201d08f518831b612aced8f4be1054a6df2fb
+Subproject commit 85f41dfdb606664cd8bb256dff943bf81aa8816d

From bb4b5aafb602f924282593a3312fd15f20b248a7 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 15 Mar 2024 05:12:11 +0800
Subject: [PATCH 107/132] Update submodule cudf to
 769c1bd6c05f3734044762c9efe3c65ef22cddbd (#1872)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 85f41dfdb6..769c1bd6c0 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 85f41dfdb606664cd8bb256dff943bf81aa8816d
+Subproject commit 769c1bd6c05f3734044762c9efe3c65ef22cddbd

From 75ebd3cfb155f2ccb0513deadad9d2b85d3a66a4 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 15 Mar 2024 10:28:07 +0800
Subject: [PATCH 108/132] Update submodule cudf to
 95ce0bb0bd9fa0f2c855d7517274f96d835d861a (#1873)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 769c1bd6c0..95ce0bb0bd 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 769c1bd6c05f3734044762c9efe3c65ef22cddbd
+Subproject commit 95ce0bb0bd9fa0f2c855d7517274f96d835d861a

From 6da7086dfccdfa25e51094e53ad9f49676dd3548 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Sat, 16 Mar 2024 05:11:24 +0800
Subject: [PATCH 109/132] Update submodule cudf to
 f305a550aecece7ceb919e4e79bf4cfe761897eb (#1875)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 95ce0bb0bd..f305a550ae 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 95ce0bb0bd9fa0f2c855d7517274f96d835d861a
+Subproject commit f305a550aecece7ceb919e4e79bf4cfe761897eb

From 2753b016ed7f799f6d9555ad0782b5c18b6c9eb1 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Sat, 16 Mar 2024 10:30:03 +0800
Subject: [PATCH 110/132] Update submodule cudf to
 f697b3eaac829b366c55b0224d558bbb28ffa06f (#1876)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index f305a550ae..f697b3eaac 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit f305a550aecece7ceb919e4e79bf4cfe761897eb
+Subproject commit f697b3eaac829b366c55b0224d558bbb28ffa06f

From e1386b5a4f3ec60be4ba290064ebbbae8d17aa43 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 19 Mar 2024 04:36:37 +0800
Subject: [PATCH 111/132] Update submodule cudf to
 fa6130f805ad8b6b9fa44722791a9aabb40a7ce2 (#1878)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index f697b3eaac..fa6130f805 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit f697b3eaac829b366c55b0224d558bbb28ffa06f
+Subproject commit fa6130f805ad8b6b9fa44722791a9aabb40a7ce2

From c4d645eb86e0c30c181639afd30ac58a3da41d91 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 19 Mar 2024 10:28:01 +0800
Subject: [PATCH 112/132] Update submodule cudf to
 e435953438ac20c4079854d54b9abffbbd3ba1ff (#1879)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index fa6130f805..e435953438 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit fa6130f805ad8b6b9fa44722791a9aabb40a7ce2
+Subproject commit e435953438ac20c4079854d54b9abffbbd3ba1ff

From 1a7682c5bda2a405cf9d7d08057116f99de08750 Mon Sep 17 00:00:00 2001
From: YanxuanLiu <104543031+YanxuanLiu@users.noreply.github.com>
Date: Tue, 19 Mar 2024 10:58:17 +0800
Subject: [PATCH 113/132] Add guardword to hide cloud server info in pipeline
 (#1874)

* change container name

Signed-off-by: YanxuanLiu <yanxuanl@nvidia.com>

* add guardword for cloud server

Signed-off-by: YanxuanLiu <yanxuanl@nvidia.com>

---------

Signed-off-by: YanxuanLiu <yanxuanl@nvidia.com>
---
 ci/Jenkinsfile.premerge | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ci/Jenkinsfile.premerge b/ci/Jenkinsfile.premerge
index ea9a1f5d78..ca62d590a3 100644
--- a/ci/Jenkinsfile.premerge
+++ b/ci/Jenkinsfile.premerge
@@ -234,6 +234,7 @@ git --no-pager diff --name-only HEAD \$BASE -- ${PREMERGE_DOCKERFILE} || true"""
                     // upload log only in case of build failure
                     def guardWords = ["gitlab.*?\\.com", "urm.*?\\.com"]
                     guardWords.add("nvidia-smi(?s)(.*?)(?=git)") // hide GPU info
+                    guardWords.add("sc-ipp*") // hide cloud info
                     githubHelper.uploadLogs(this, env.JOB_NAME, env.BUILD_NUMBER, null, guardWords)
 
                     githubHelper.updateCommitStatus("$BUILD_URL", "Fail", GitHubCommitState.FAILURE)

From 2dfb72b977321a3a09c4be8b50ab71e63afbf4d8 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 19 Mar 2024 16:27:43 +0800
Subject: [PATCH 114/132] Update submodule cudf to
 ea405968a2986fb4e71fbc30e7f9370e48f6344b (#1880)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index e435953438..ea405968a2 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit e435953438ac20c4079854d54b9abffbbd3ba1ff
+Subproject commit ea405968a2986fb4e71fbc30e7f9370e48f6344b

From ee4ef361a789471695ffbec210d1b7f5d00b243a Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 20 Mar 2024 11:32:53 +0800
Subject: [PATCH 115/132] Update submodule cudf to
 f9ac4277f50163a7da2006460034aa3e45c8744e (#1881)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index ea405968a2..f9ac4277f5 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit ea405968a2986fb4e71fbc30e7f9370e48f6344b
+Subproject commit f9ac4277f50163a7da2006460034aa3e45c8744e

From 5f642babe54a268966e107ae8007268871229a9a Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 21 Mar 2024 11:12:37 +0800
Subject: [PATCH 116/132] Update submodule cudf to
 08bd78310eee1100adf14a098a0d579175e062da (#1883)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index f9ac4277f5..08bd78310e 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit f9ac4277f50163a7da2006460034aa3e45c8744e
+Subproject commit 08bd78310eee1100adf14a098a0d579175e062da

From d8771daa4429d632734f9a526651d85067de5d4e Mon Sep 17 00:00:00 2001
From: Gary Shen <gashen@nvidia.com>
Date: Thu, 21 Mar 2024 12:34:32 +0800
Subject: [PATCH 117/132] Support cudf pin with rapids-cmake (#1877)

* Use rapids-cmake to pin cudf dependencies to known working SHA1's

* Use git download rapids-cmake

So that we can get SHA
Use same format of CopyRight
Use cudf/rapids_config.cmake which is renamed from fetch_rapids.cmake
Update versions to latest

Signed-off-by: Gary Shen <gashen@nvidia.com>

* Commit cudf to the latest code before mvn verify

Signed-off-by: Gary Shen <gashen@nvidia.com>

* Remove the first commit of cudf

since the second one can commit it at once

Signed-off-by: Gary Shen <gashen@nvidia.com>

---------

Signed-off-by: Gary Shen <gashen@nvidia.com>
Co-authored-by: Robert Maynard <rmaynard@nvidia.com>
---
 build-libcudf.xml                             |   4 +-
 ci/submodule-sync.sh                          |  15 ++-
 pom.xml                                       |   2 +
 .../cudf-pins/add_dependency_pins.cmake       |  37 ++++++
 thirdparty/cudf-pins/rapids-cmake.sha         |   1 +
 thirdparty/cudf-pins/setup.cmake              |  45 +++++++
 thirdparty/cudf-pins/versions.json            | 110 ++++++++++++++++++
 7 files changed, 211 insertions(+), 3 deletions(-)
 create mode 100644 thirdparty/cudf-pins/add_dependency_pins.cmake
 create mode 100644 thirdparty/cudf-pins/rapids-cmake.sha
 create mode 100644 thirdparty/cudf-pins/setup.cmake
 create mode 100644 thirdparty/cudf-pins/versions.json

diff --git a/build-libcudf.xml b/build-libcudf.xml
index f4068c180d..778e668bbe 100644
--- a/build-libcudf.xml
+++ b/build-libcudf.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0"?>
 <!--
-  Copyright (c) 2022, NVIDIA CORPORATION.
+  Copyright (c) 2022-2024, NVIDIA CORPORATION.
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -40,6 +40,7 @@
       <arg value="-DBUILD_TESTS=OFF"/>
       <arg value="-DCMAKE_CUDA_ARCHITECTURES=${GPU_ARCHS}"/>
       <arg value="-DCMAKE_INSTALL_PREFIX=${libcudf.install.path}"/>
+      <arg value="-DCUDF_DEPENDENCY_PIN_MODE=${libcudf.dependency.mode}"/>
       <arg value="-DCUDA_STATIC_RUNTIME=ON"/>
       <arg value="-DCUDF_ENABLE_ARROW_S3=OFF"/>
       <arg value="-DCUDF_ENABLE_ARROW_PARQUET=ON"/>
@@ -47,6 +48,7 @@
       <arg value="-DCUDF_USE_PER_THREAD_DEFAULT_STREAM=${CUDF_USE_PER_THREAD_DEFAULT_STREAM}" />
       <arg value="-DRMM_LOGGING_LEVEL=${RMM_LOGGING_LEVEL}" />
       <arg value="-DUSE_GDS=${USE_GDS}" />
+      <arg value="-C=${cudf.pin.path}/setup.cmake"/>
     </exec>
 
     <exec dir="${libcudf.build.path}"
diff --git a/ci/submodule-sync.sh b/ci/submodule-sync.sh
index 8822b3cf7b..18119dc45d 100755
--- a/ci/submodule-sync.sh
+++ b/ci/submodule-sync.sh
@@ -65,8 +65,6 @@ fi
 
 echo "Try update cudf submodule to ${cudf_sha}..."
 git add .
-git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${CUDF_TAG:-$cudf_sha}"
-sha=$(git rev-parse HEAD)
 
 echo "Test against ${cudf_sha}..."
 
@@ -75,6 +73,7 @@ set +e
 ${MVN} verify ${MVN_MIRROR} \
   -DCPP_PARALLEL_LEVEL=${PARALLEL_LEVEL} \
   -Dlibcudf.build.configure=true \
+  -Dlibcudf.dependency.mode=latest \
   -DUSE_GDS=ON -Dtest=*,!CuFileTest,!CudaFatalTest,!ColumnViewNonEmptyNullsTest \
   -DBUILD_TESTS=ON \
   -DUSE_SANITIZER=ON
@@ -89,6 +88,18 @@ else
   echo "Test failed, will update the result"
 fi
 
+# Extract the rapids-cmake sha1 that we need to pin too
+rapids_cmake_sha=$(git -C thirdparty/cudf/cpp/build/_deps/rapids-cmake-src/ rev-parse HEAD)
+echo "Update rapids-cmake pinned SHA1 to ${rapids_cmake_sha}"
+echo "${rapids_cmake_sha}" > thirdparty/cudf-pins/rapids-cmake.sha
+
+# Do the git add after the build so that we get
+# the updated versions.json generated by the build
+echo "Update cudf submodule to ${cudf_sha} with updated pinned versions"
+git add .
+git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${cudf_sha}"
+sha=$(git rev-parse HEAD)
+
 # push the intermediate branch and create PR against REF
 # if test passed, it will try auto-merge the PR
 # if test failed, it will only comment the test result in the PR
diff --git a/pom.xml b/pom.xml
index f7a4fcd354..8dca17cf3e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -89,12 +89,14 @@
     <cuda.version>cuda11</cuda.version>
     <jni.classifier>${cuda.version}</jni.classifier>
     <cudf.path>${project.basedir}/thirdparty/cudf</cudf.path>
+    <cudf.pin.path>${project.basedir}/thirdparty/cudf-pins/</cudf.pin.path>
     <hadoop.version>3.2.4</hadoop.version>
     <junit.version>5.8.1</junit.version>
     <libcudf.build.path>${cudf.path}/cpp/build</libcudf.build.path>
     <libcudf.build.configure>false</libcudf.build.configure>
     <libcudf.clean.skip>true</libcudf.clean.skip>
     <libcudf.install.path>${project.build.directory}/libcudf-install</libcudf.install.path>
+    <libcudf.dependency.mode>pinned</libcudf.dependency.mode>
     <libcudfjni.build.path>${project.build.directory}/libcudfjni</libcudfjni.build.path>
     <maven.compiler.source>1.8</maven.compiler.source>
     <maven.compiler.target>1.8</maven.compiler.target>
diff --git a/thirdparty/cudf-pins/add_dependency_pins.cmake b/thirdparty/cudf-pins/add_dependency_pins.cmake
new file mode 100644
index 0000000000..73e0ebab76
--- /dev/null
+++ b/thirdparty/cudf-pins/add_dependency_pins.cmake
@@ -0,0 +1,37 @@
+#
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+if(NOT DEFINED rapids-cmake-dir)
+  include(../cudf/rapids_config.cmake)
+endif()
+
+include(rapids-cpm)
+rapids_cpm_init()
+
+function(add_override_if_requested)
+  if(CUDF_DEPENDENCY_PIN_MODE STREQUAL pinned)
+    include(${rapids-cmake-dir}/cpm/package_override.cmake)
+    rapids_cpm_package_override(${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json)
+
+    message(STATUS "Pinning CUDF dependencies to values found in ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json")
+  else()
+    include(${rapids-cmake-dir}/cpm/generate_pinned_versions.cmake)
+    rapids_cpm_generate_pinned_versions(OUTPUT ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json)
+
+    message(STATUS "Building with latest CUDF dependencies (saving pinned versions to ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json)")
+  endif()
+endfunction()
+add_override_if_requested()
diff --git a/thirdparty/cudf-pins/rapids-cmake.sha b/thirdparty/cudf-pins/rapids-cmake.sha
new file mode 100644
index 0000000000..7644ee04e3
--- /dev/null
+++ b/thirdparty/cudf-pins/rapids-cmake.sha
@@ -0,0 +1 @@
+d0670231b614f757645e6b3d4f456fea89aa282a
diff --git a/thirdparty/cudf-pins/setup.cmake b/thirdparty/cudf-pins/setup.cmake
new file mode 100644
index 0000000000..8040c26faf
--- /dev/null
+++ b/thirdparty/cudf-pins/setup.cmake
@@ -0,0 +1,45 @@
+#
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+string(TOLOWER "${CUDF_DEPENDENCY_PIN_MODE}" CUDF_DEPENDENCY_PIN_MODE)
+if(NOT (CUDF_DEPENDENCY_PIN_MODE STREQUAL pinned OR
+        CUDF_DEPENDENCY_PIN_MODE STREQUAL latest))
+  message(FATAL_ERROR "The CUDF_DEPENDENCY_PIN_MODE variable must be set to either `pinned` or `latest`.")
+ endif()
+
+function(set_rapids_cmake_pin_sha1)
+  set(rapids-cmake-sha "${rapids-cmake-sha}" PARENT_SCOPE)
+
+  message(STATUS "Pinning rapids-cmake SHA1 to ${rapids-cmake-sha}")
+endfunction()
+
+# We need to set the rapids-cmake SHA1 before any CMake code in libcudf is executed when
+# we are in pin mode. Otherwise we will use the latest rapids-cmake version since that
+# is what cudf does via `fetch_rapids.cmake`
+if(CUDF_DEPENDENCY_PIN_MODE STREQUAL pinned)
+  # Extract the rapids sha1 from the file
+  file(READ "${CMAKE_CURRENT_LIST_DIR}/rapids-cmake.sha" rapids-cmake-sha)
+  string(STRIP rapids-cmake-sha "${rapids-cmake-sha}")
+  string(REPLACE "\n" "" rapids-cmake-sha "${rapids-cmake-sha}")
+  set(rapids-cmake-sha "${rapids-cmake-sha}" CACHE STRING "rapids-cmake sha to use" FORCE)
+  message(STATUS "Pinning rapids-cmake SHA1 [${rapids-cmake-sha}]")
+else()
+  set(rapids-cmake-fetch-via-git "ON" CACHE STRING "Make sure rapids-cmake is cloned so we can get SHA value" FORCE)
+endif()
+
+# We need to use a project() call hook, since rapids-cmake cpm_init()
+# can't be called from a `-C` CMake file
+set(CMAKE_PROJECT_TOP_LEVEL_INCLUDES "${CMAKE_CURRENT_LIST_DIR}/add_dependency_pins.cmake" CACHE FILEPATH "" )
diff --git a/thirdparty/cudf-pins/versions.json b/thirdparty/cudf-pins/versions.json
new file mode 100644
index 0000000000..673fbd390b
--- /dev/null
+++ b/thirdparty/cudf-pins/versions.json
@@ -0,0 +1,110 @@
+{
+  "packages" : 
+  {
+    "Arrow" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "740889f413af9b1ae1d81eb1e5a4a9fb4ce9cf97",
+      "git_url" : "https://github.com/apache/arrow.git",
+      "version" : "14.0.2"
+    },
+    "CCCL" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "36f379f29660761fe033a1306ca9dab6a88cb65c",
+      "git_url" : "https://github.com/NVIDIA/cccl.git",
+      "patches" : 
+      [
+        {
+          "file" : "cccl/bug_fixes.diff",
+          "fixed_in" : "2.3",
+          "issue" : "CCCL installs header-search.cmake files in nondeterministic order and has a typo in checking target creation that leads to duplicates"
+        },
+        {
+          "file" : "cccl/hide_kernels.diff",
+          "fixed_in" : "2.3",
+          "issue" : "Mark all cub and thrust kernels with hidden visibility [https://github.com/nvidia/cccl/pulls/443]"
+        },
+        {
+          "file" : "cccl/revert_pr_211.diff",
+          "fixed_in" : "",
+          "issue" : "thrust::copy introduced a change in behavior that causes failures with cudaErrorInvalidValue."
+        },
+        {
+          "file" : "${current_json_dir}/thrust_disable_64bit_dispatching.diff",
+          "fixed_in" : "",
+          "issue" : "Remove 64bit dispatching as not needed by libcudf and results in compiling twice as many kernels [https://github.com/rapidsai/cudf/pull/11437]"
+        },
+        {
+          "file" : "${current_json_dir}/thrust_faster_sort_compile_times.diff",
+          "fixed_in" : "",
+          "issue" : "Improve Thrust sort compile times by not unrolling loops for inlined comparators [https://github.com/rapidsai/cudf/pull/10577]"
+        },
+        {
+          "file" : "${current_json_dir}/thrust_faster_scan_compile_times.diff",
+          "fixed_in" : "",
+          "issue" : "Improve Thrust scan compile times by reducing the number of kernels generated [https://github.com/rapidsai/cudf/pull/8183]"
+        }
+      ],
+      "version" : "2.2.0"
+    },
+    "GTest" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "b796f7d44681514f58a683a3a71ff17c94edb0c1",
+      "git_url" : "https://github.com/google/googletest.git",
+      "version" : "1.13.0"
+    },
+    "KvikIO" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "30b1dc1aa9dc8694fc7babb81e33664c56a9b2ff",
+      "git_url" : "https://github.com/rapidsai/kvikio.git",
+      "version" : "24.04.0"
+    },
+    "NVTX3" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "e170594ac7cf1dac584da473d4ca9301087090c1",
+      "git_url" : "https://github.com/NVIDIA/NVTX.git",
+      "version" : "3.1.0"
+    },
+    "cuco" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "56c53beb6fb0cafd265b7fcc3df78ae487811b22",
+      "git_url" : "https://github.com/NVIDIA/cuCollections.git",
+      "version" : "0.0.1"
+    },
+    "dlpack" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "365b823cedb281cd0240ca601aba9b78771f91a3",
+      "git_url" : "https://github.com/dmlc/dlpack.git",
+      "version" : "0.8"
+    },
+    "jitify" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "047df5e87d84834f8f4225898476145741acfa80",
+      "git_url" : "https://github.com/rapidsai/jitify.git",
+      "version" : "2.0.0"
+    },
+    "rmm" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "2c161dad4aa732e7a6901ab512aa9a0fac85afc4",
+      "git_url" : "https://github.com/rapidsai/rmm.git",
+      "version" : "24.04.0"
+    }
+  }
+}

From 58780b32fdea7ced2f5f7e4dd9e3e5f87ba5559c Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Fri, 22 Mar 2024 04:36:16 +0800
Subject: [PATCH 118/132] Update submodule cudf to
 23aad9ec76ca0367be994a551a9b0a4838839883 (#1884)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf                       |  2 +-
 thirdparty/cudf-pins/rapids-cmake.sha |  2 +-
 thirdparty/cudf-pins/versions.json    | 55 ++++++++++++++++++++++++---
 3 files changed, 52 insertions(+), 7 deletions(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 08bd78310e..23aad9ec76 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 08bd78310eee1100adf14a098a0d579175e062da
+Subproject commit 23aad9ec76ca0367be994a551a9b0a4838839883
diff --git a/thirdparty/cudf-pins/rapids-cmake.sha b/thirdparty/cudf-pins/rapids-cmake.sha
index 7644ee04e3..c1a4d9b064 100644
--- a/thirdparty/cudf-pins/rapids-cmake.sha
+++ b/thirdparty/cudf-pins/rapids-cmake.sha
@@ -1 +1 @@
-d0670231b614f757645e6b3d4f456fea89aa282a
+12ae981533913b6a411c6e2a3e8d1232b0c9727a
diff --git a/thirdparty/cudf-pins/versions.json b/thirdparty/cudf-pins/versions.json
index 673fbd390b..a62e10cebb 100644
--- a/thirdparty/cudf-pins/versions.json
+++ b/thirdparty/cudf-pins/versions.json
@@ -62,9 +62,9 @@
     {
       "always_download" : true,
       "git_shallow" : false,
-      "git_tag" : "30b1dc1aa9dc8694fc7babb81e33664c56a9b2ff",
+      "git_tag" : "41b473d4368b22585b54026d77a5889434bee2e5",
       "git_url" : "https://github.com/rapidsai/kvikio.git",
-      "version" : "24.04.0"
+      "version" : "24.04"
     },
     "NVTX3" : 
     {
@@ -90,6 +90,22 @@
       "git_url" : "https://github.com/dmlc/dlpack.git",
       "version" : "0.8"
     },
+    "fmt" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "f5e54359df4c26b6230fc61d38aa294581393084",
+      "git_url" : "https://github.com/fmtlib/fmt.git",
+      "patches" : 
+      [
+        {
+          "file" : "fmt/fix_10_1_1_version.diff",
+          "fixed_in" : "10.2.0",
+          "issue" : "fmt 10.1.1 produces a CMake package with version 10.1.0"
+        }
+      ],
+      "version" : "10.1.1"
+    },
     "jitify" : 
     {
       "always_download" : true,
@@ -98,13 +114,42 @@
       "git_url" : "https://github.com/rapidsai/jitify.git",
       "version" : "2.0.0"
     },
+    "nvcomp" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "v2.2.0",
+      "git_url" : "https://github.com/NVIDIA/nvcomp.git",
+      "proprietary_binary" : 
+      {
+        "aarch64-linux" : "https://developer.download.nvidia.com/compute/nvcomp/${version}/local_installers/nvcomp_${version}_SBSA_${cuda-toolkit-version-major}.x.tgz",
+        "x86_64-linux" : "https://developer.download.nvidia.com/compute/nvcomp/${version}/local_installers/nvcomp_${version}_x86_64_${cuda-toolkit-version-major}.x.tgz"
+      },
+      "version" : "3.0.6"
+    },
     "rmm" : 
     {
       "always_download" : true,
       "git_shallow" : false,
-      "git_tag" : "2c161dad4aa732e7a6901ab512aa9a0fac85afc4",
+      "git_tag" : "a98931b91ae8109f478469fd4eec388cf86b81fb",
       "git_url" : "https://github.com/rapidsai/rmm.git",
-      "version" : "24.04.0"
+      "version" : "24.04"
+    },
+    "spdlog" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "7e635fca68d014934b4af8a1cf874f63989352b7",
+      "git_url" : "https://github.com/gabime/spdlog.git",
+      "patches" : 
+      [
+        {
+          "file" : "spdlog/nvcc_constexpr_fix.diff",
+          "fixed_in" : "1.13",
+          "issue" : "Fix constexpr mismatch between spdlog and fmt [https://github.com/gabime/spdlog/issues/2856]"
+        }
+      ],
+      "version" : "1.12.0"
     }
   }
-}
+}
\ No newline at end of file

From 8247a94b567f03689873ae8d43330d1eda9cafa8 Mon Sep 17 00:00:00 2001
From: Jason Lowe <jlowe@nvidia.com>
Date: Mon, 25 Mar 2024 13:21:41 -0700
Subject: [PATCH 119/132] Revert "Support cudf pin with rapids-cmake (#1877)"
 (#1895)

This reverts commit d8771daa4429d632734f9a526651d85067de5d4e.

Signed-off-by: Jason Lowe <jlowe@nvidia.com>
---
 build-libcudf.xml                             |   4 +-
 ci/submodule-sync.sh                          |  15 +-
 pom.xml                                       |   2 -
 .../cudf-pins/add_dependency_pins.cmake       |  37 -----
 thirdparty/cudf-pins/rapids-cmake.sha         |   1 -
 thirdparty/cudf-pins/setup.cmake              |  45 -----
 thirdparty/cudf-pins/versions.json            | 155 ------------------
 7 files changed, 3 insertions(+), 256 deletions(-)
 delete mode 100644 thirdparty/cudf-pins/add_dependency_pins.cmake
 delete mode 100644 thirdparty/cudf-pins/rapids-cmake.sha
 delete mode 100644 thirdparty/cudf-pins/setup.cmake
 delete mode 100644 thirdparty/cudf-pins/versions.json

diff --git a/build-libcudf.xml b/build-libcudf.xml
index 778e668bbe..f4068c180d 100644
--- a/build-libcudf.xml
+++ b/build-libcudf.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0"?>
 <!--
-  Copyright (c) 2022-2024, NVIDIA CORPORATION.
+  Copyright (c) 2022, NVIDIA CORPORATION.
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -40,7 +40,6 @@
       <arg value="-DBUILD_TESTS=OFF"/>
       <arg value="-DCMAKE_CUDA_ARCHITECTURES=${GPU_ARCHS}"/>
       <arg value="-DCMAKE_INSTALL_PREFIX=${libcudf.install.path}"/>
-      <arg value="-DCUDF_DEPENDENCY_PIN_MODE=${libcudf.dependency.mode}"/>
       <arg value="-DCUDA_STATIC_RUNTIME=ON"/>
       <arg value="-DCUDF_ENABLE_ARROW_S3=OFF"/>
       <arg value="-DCUDF_ENABLE_ARROW_PARQUET=ON"/>
@@ -48,7 +47,6 @@
       <arg value="-DCUDF_USE_PER_THREAD_DEFAULT_STREAM=${CUDF_USE_PER_THREAD_DEFAULT_STREAM}" />
       <arg value="-DRMM_LOGGING_LEVEL=${RMM_LOGGING_LEVEL}" />
       <arg value="-DUSE_GDS=${USE_GDS}" />
-      <arg value="-C=${cudf.pin.path}/setup.cmake"/>
     </exec>
 
     <exec dir="${libcudf.build.path}"
diff --git a/ci/submodule-sync.sh b/ci/submodule-sync.sh
index 18119dc45d..8822b3cf7b 100755
--- a/ci/submodule-sync.sh
+++ b/ci/submodule-sync.sh
@@ -65,6 +65,8 @@ fi
 
 echo "Try update cudf submodule to ${cudf_sha}..."
 git add .
+git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${CUDF_TAG:-$cudf_sha}"
+sha=$(git rev-parse HEAD)
 
 echo "Test against ${cudf_sha}..."
 
@@ -73,7 +75,6 @@ set +e
 ${MVN} verify ${MVN_MIRROR} \
   -DCPP_PARALLEL_LEVEL=${PARALLEL_LEVEL} \
   -Dlibcudf.build.configure=true \
-  -Dlibcudf.dependency.mode=latest \
   -DUSE_GDS=ON -Dtest=*,!CuFileTest,!CudaFatalTest,!ColumnViewNonEmptyNullsTest \
   -DBUILD_TESTS=ON \
   -DUSE_SANITIZER=ON
@@ -88,18 +89,6 @@ else
   echo "Test failed, will update the result"
 fi
 
-# Extract the rapids-cmake sha1 that we need to pin too
-rapids_cmake_sha=$(git -C thirdparty/cudf/cpp/build/_deps/rapids-cmake-src/ rev-parse HEAD)
-echo "Update rapids-cmake pinned SHA1 to ${rapids_cmake_sha}"
-echo "${rapids_cmake_sha}" > thirdparty/cudf-pins/rapids-cmake.sha
-
-# Do the git add after the build so that we get
-# the updated versions.json generated by the build
-echo "Update cudf submodule to ${cudf_sha} with updated pinned versions"
-git add .
-git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${cudf_sha}"
-sha=$(git rev-parse HEAD)
-
 # push the intermediate branch and create PR against REF
 # if test passed, it will try auto-merge the PR
 # if test failed, it will only comment the test result in the PR
diff --git a/pom.xml b/pom.xml
index 8dca17cf3e..f7a4fcd354 100644
--- a/pom.xml
+++ b/pom.xml
@@ -89,14 +89,12 @@
     <cuda.version>cuda11</cuda.version>
     <jni.classifier>${cuda.version}</jni.classifier>
     <cudf.path>${project.basedir}/thirdparty/cudf</cudf.path>
-    <cudf.pin.path>${project.basedir}/thirdparty/cudf-pins/</cudf.pin.path>
     <hadoop.version>3.2.4</hadoop.version>
     <junit.version>5.8.1</junit.version>
     <libcudf.build.path>${cudf.path}/cpp/build</libcudf.build.path>
     <libcudf.build.configure>false</libcudf.build.configure>
     <libcudf.clean.skip>true</libcudf.clean.skip>
     <libcudf.install.path>${project.build.directory}/libcudf-install</libcudf.install.path>
-    <libcudf.dependency.mode>pinned</libcudf.dependency.mode>
     <libcudfjni.build.path>${project.build.directory}/libcudfjni</libcudfjni.build.path>
     <maven.compiler.source>1.8</maven.compiler.source>
     <maven.compiler.target>1.8</maven.compiler.target>
diff --git a/thirdparty/cudf-pins/add_dependency_pins.cmake b/thirdparty/cudf-pins/add_dependency_pins.cmake
deleted file mode 100644
index 73e0ebab76..0000000000
--- a/thirdparty/cudf-pins/add_dependency_pins.cmake
+++ /dev/null
@@ -1,37 +0,0 @@
-#
-# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-if(NOT DEFINED rapids-cmake-dir)
-  include(../cudf/rapids_config.cmake)
-endif()
-
-include(rapids-cpm)
-rapids_cpm_init()
-
-function(add_override_if_requested)
-  if(CUDF_DEPENDENCY_PIN_MODE STREQUAL pinned)
-    include(${rapids-cmake-dir}/cpm/package_override.cmake)
-    rapids_cpm_package_override(${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json)
-
-    message(STATUS "Pinning CUDF dependencies to values found in ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json")
-  else()
-    include(${rapids-cmake-dir}/cpm/generate_pinned_versions.cmake)
-    rapids_cpm_generate_pinned_versions(OUTPUT ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json)
-
-    message(STATUS "Building with latest CUDF dependencies (saving pinned versions to ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json)")
-  endif()
-endfunction()
-add_override_if_requested()
diff --git a/thirdparty/cudf-pins/rapids-cmake.sha b/thirdparty/cudf-pins/rapids-cmake.sha
deleted file mode 100644
index c1a4d9b064..0000000000
--- a/thirdparty/cudf-pins/rapids-cmake.sha
+++ /dev/null
@@ -1 +0,0 @@
-12ae981533913b6a411c6e2a3e8d1232b0c9727a
diff --git a/thirdparty/cudf-pins/setup.cmake b/thirdparty/cudf-pins/setup.cmake
deleted file mode 100644
index 8040c26faf..0000000000
--- a/thirdparty/cudf-pins/setup.cmake
+++ /dev/null
@@ -1,45 +0,0 @@
-#
-# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-string(TOLOWER "${CUDF_DEPENDENCY_PIN_MODE}" CUDF_DEPENDENCY_PIN_MODE)
-if(NOT (CUDF_DEPENDENCY_PIN_MODE STREQUAL pinned OR
-        CUDF_DEPENDENCY_PIN_MODE STREQUAL latest))
-  message(FATAL_ERROR "The CUDF_DEPENDENCY_PIN_MODE variable must be set to either `pinned` or `latest`.")
- endif()
-
-function(set_rapids_cmake_pin_sha1)
-  set(rapids-cmake-sha "${rapids-cmake-sha}" PARENT_SCOPE)
-
-  message(STATUS "Pinning rapids-cmake SHA1 to ${rapids-cmake-sha}")
-endfunction()
-
-# We need to set the rapids-cmake SHA1 before any CMake code in libcudf is executed when
-# we are in pin mode. Otherwise we will use the latest rapids-cmake version since that
-# is what cudf does via `fetch_rapids.cmake`
-if(CUDF_DEPENDENCY_PIN_MODE STREQUAL pinned)
-  # Extract the rapids sha1 from the file
-  file(READ "${CMAKE_CURRENT_LIST_DIR}/rapids-cmake.sha" rapids-cmake-sha)
-  string(STRIP rapids-cmake-sha "${rapids-cmake-sha}")
-  string(REPLACE "\n" "" rapids-cmake-sha "${rapids-cmake-sha}")
-  set(rapids-cmake-sha "${rapids-cmake-sha}" CACHE STRING "rapids-cmake sha to use" FORCE)
-  message(STATUS "Pinning rapids-cmake SHA1 [${rapids-cmake-sha}]")
-else()
-  set(rapids-cmake-fetch-via-git "ON" CACHE STRING "Make sure rapids-cmake is cloned so we can get SHA value" FORCE)
-endif()
-
-# We need to use a project() call hook, since rapids-cmake cpm_init()
-# can't be called from a `-C` CMake file
-set(CMAKE_PROJECT_TOP_LEVEL_INCLUDES "${CMAKE_CURRENT_LIST_DIR}/add_dependency_pins.cmake" CACHE FILEPATH "" )
diff --git a/thirdparty/cudf-pins/versions.json b/thirdparty/cudf-pins/versions.json
deleted file mode 100644
index a62e10cebb..0000000000
--- a/thirdparty/cudf-pins/versions.json
+++ /dev/null
@@ -1,155 +0,0 @@
-{
-  "packages" : 
-  {
-    "Arrow" : 
-    {
-      "always_download" : true,
-      "git_shallow" : false,
-      "git_tag" : "740889f413af9b1ae1d81eb1e5a4a9fb4ce9cf97",
-      "git_url" : "https://github.com/apache/arrow.git",
-      "version" : "14.0.2"
-    },
-    "CCCL" : 
-    {
-      "always_download" : true,
-      "git_shallow" : false,
-      "git_tag" : "36f379f29660761fe033a1306ca9dab6a88cb65c",
-      "git_url" : "https://github.com/NVIDIA/cccl.git",
-      "patches" : 
-      [
-        {
-          "file" : "cccl/bug_fixes.diff",
-          "fixed_in" : "2.3",
-          "issue" : "CCCL installs header-search.cmake files in nondeterministic order and has a typo in checking target creation that leads to duplicates"
-        },
-        {
-          "file" : "cccl/hide_kernels.diff",
-          "fixed_in" : "2.3",
-          "issue" : "Mark all cub and thrust kernels with hidden visibility [https://github.com/nvidia/cccl/pulls/443]"
-        },
-        {
-          "file" : "cccl/revert_pr_211.diff",
-          "fixed_in" : "",
-          "issue" : "thrust::copy introduced a change in behavior that causes failures with cudaErrorInvalidValue."
-        },
-        {
-          "file" : "${current_json_dir}/thrust_disable_64bit_dispatching.diff",
-          "fixed_in" : "",
-          "issue" : "Remove 64bit dispatching as not needed by libcudf and results in compiling twice as many kernels [https://github.com/rapidsai/cudf/pull/11437]"
-        },
-        {
-          "file" : "${current_json_dir}/thrust_faster_sort_compile_times.diff",
-          "fixed_in" : "",
-          "issue" : "Improve Thrust sort compile times by not unrolling loops for inlined comparators [https://github.com/rapidsai/cudf/pull/10577]"
-        },
-        {
-          "file" : "${current_json_dir}/thrust_faster_scan_compile_times.diff",
-          "fixed_in" : "",
-          "issue" : "Improve Thrust scan compile times by reducing the number of kernels generated [https://github.com/rapidsai/cudf/pull/8183]"
-        }
-      ],
-      "version" : "2.2.0"
-    },
-    "GTest" : 
-    {
-      "always_download" : true,
-      "git_shallow" : false,
-      "git_tag" : "b796f7d44681514f58a683a3a71ff17c94edb0c1",
-      "git_url" : "https://github.com/google/googletest.git",
-      "version" : "1.13.0"
-    },
-    "KvikIO" : 
-    {
-      "always_download" : true,
-      "git_shallow" : false,
-      "git_tag" : "41b473d4368b22585b54026d77a5889434bee2e5",
-      "git_url" : "https://github.com/rapidsai/kvikio.git",
-      "version" : "24.04"
-    },
-    "NVTX3" : 
-    {
-      "always_download" : true,
-      "git_shallow" : false,
-      "git_tag" : "e170594ac7cf1dac584da473d4ca9301087090c1",
-      "git_url" : "https://github.com/NVIDIA/NVTX.git",
-      "version" : "3.1.0"
-    },
-    "cuco" : 
-    {
-      "always_download" : true,
-      "git_shallow" : false,
-      "git_tag" : "56c53beb6fb0cafd265b7fcc3df78ae487811b22",
-      "git_url" : "https://github.com/NVIDIA/cuCollections.git",
-      "version" : "0.0.1"
-    },
-    "dlpack" : 
-    {
-      "always_download" : true,
-      "git_shallow" : false,
-      "git_tag" : "365b823cedb281cd0240ca601aba9b78771f91a3",
-      "git_url" : "https://github.com/dmlc/dlpack.git",
-      "version" : "0.8"
-    },
-    "fmt" : 
-    {
-      "always_download" : true,
-      "git_shallow" : false,
-      "git_tag" : "f5e54359df4c26b6230fc61d38aa294581393084",
-      "git_url" : "https://github.com/fmtlib/fmt.git",
-      "patches" : 
-      [
-        {
-          "file" : "fmt/fix_10_1_1_version.diff",
-          "fixed_in" : "10.2.0",
-          "issue" : "fmt 10.1.1 produces a CMake package with version 10.1.0"
-        }
-      ],
-      "version" : "10.1.1"
-    },
-    "jitify" : 
-    {
-      "always_download" : true,
-      "git_shallow" : false,
-      "git_tag" : "047df5e87d84834f8f4225898476145741acfa80",
-      "git_url" : "https://github.com/rapidsai/jitify.git",
-      "version" : "2.0.0"
-    },
-    "nvcomp" : 
-    {
-      "always_download" : true,
-      "git_shallow" : false,
-      "git_tag" : "v2.2.0",
-      "git_url" : "https://github.com/NVIDIA/nvcomp.git",
-      "proprietary_binary" : 
-      {
-        "aarch64-linux" : "https://developer.download.nvidia.com/compute/nvcomp/${version}/local_installers/nvcomp_${version}_SBSA_${cuda-toolkit-version-major}.x.tgz",
-        "x86_64-linux" : "https://developer.download.nvidia.com/compute/nvcomp/${version}/local_installers/nvcomp_${version}_x86_64_${cuda-toolkit-version-major}.x.tgz"
-      },
-      "version" : "3.0.6"
-    },
-    "rmm" : 
-    {
-      "always_download" : true,
-      "git_shallow" : false,
-      "git_tag" : "a98931b91ae8109f478469fd4eec388cf86b81fb",
-      "git_url" : "https://github.com/rapidsai/rmm.git",
-      "version" : "24.04"
-    },
-    "spdlog" : 
-    {
-      "always_download" : true,
-      "git_shallow" : false,
-      "git_tag" : "7e635fca68d014934b4af8a1cf874f63989352b7",
-      "git_url" : "https://github.com/gabime/spdlog.git",
-      "patches" : 
-      [
-        {
-          "file" : "spdlog/nvcc_constexpr_fix.diff",
-          "fixed_in" : "1.13",
-          "issue" : "Fix constexpr mismatch between spdlog and fmt [https://github.com/gabime/spdlog/issues/2856]"
-        }
-      ],
-      "version" : "1.12.0"
-    }
-  }
-}
\ No newline at end of file

From 0a6245108773c43baec2a7ebb7b428f7ce3361a7 Mon Sep 17 00:00:00 2001
From: Tim Liu <timl@nvidia.com>
Date: Tue, 26 Mar 2024 09:54:23 +0800
Subject: [PATCH 120/132] Auto merge PRs to branch-24.06 from branch-24.04
 [skip ci] (#1887)

Signed-off-by: Tim Liu <timl@nvidia.com>
---
 .github/workflows/auto-merge.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/auto-merge.yml b/.github/workflows/auto-merge.yml
index 08ee4f34d8..4551103779 100755
--- a/.github/workflows/auto-merge.yml
+++ b/.github/workflows/auto-merge.yml
@@ -18,12 +18,12 @@ name: auto-merge HEAD to BASE
 on:
   pull_request_target:
     branches:
-      - branch-24.02
+      - branch-24.04
     types: [closed]
 
 env:
-  HEAD: branch-24.02
-  BASE: branch-24.04
+  HEAD: branch-24.04
+  BASE: branch-24.06
 
 jobs:
   auto-merge:

From 19f6c8b8484021a5988ea8434bf2a5f16b7d0185 Mon Sep 17 00:00:00 2001
From: Tim Liu <timl@nvidia.com>
Date: Tue, 26 Mar 2024 21:03:41 +0800
Subject: [PATCH 121/132] Pin to 3.1.0 maven-gpg-plugin in deploy script [skip
 ci] (#1888)

Refer to: https://github.com/NVIDIA/spark-rapids/issues/10624

As latest maven-gpg-plugin has the issue "error 401 Unauthorized"

when deploy files onto Sonatype repo, we pin it to the

stable version 3.1.0 to unblock our release process.

Signed-off-by: Tim Liu <timl@nvidia.com>
---
 ci/deploy.sh | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/ci/deploy.sh b/ci/deploy.sh
index c4201d0c11..710f61e678 100755
--- a/ci/deploy.sh
+++ b/ci/deploy.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-# Copyright (c) 2022-2023, NVIDIA CORPORATION. All rights reserved.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -69,14 +69,15 @@ IFS="$ORI_IFS"
 FIRST_FILE=${CLASS_FILES%%,*}
 cp -f "$FIRST_FILE" "$FPATH.jar"
 
+GPG_PLUGIN="org.apache.maven.plugins:maven-gpg-plugin:3.1.0:sign-and-deploy-file"
 ###### Build the deploy command ######
 if [ "$SIGN_FILE" == true ]; then
     case $SIGN_TOOL in
         nvsec)
-            DEPLOY_CMD="$MVN gpg:sign-and-deploy-file -Dgpg.executable=nvsec_sign"
+            DEPLOY_CMD="$MVN $GPG_PLUGIN -Dgpg.executable=nvsec_sign"
             ;;
         gpg)
-            DEPLOY_CMD="$MVN gpg:sign-and-deploy-file -Dgpg.passphrase=$GPG_PASSPHRASE "
+            DEPLOY_CMD="$MVN $GPG_PLUGIN -Dgpg.passphrase=$GPG_PASSPHRASE "
             ;;
         *)
             echo "Error unsupported sign type : $SIGN_TYPE !"

From 0dff9515396f2e111ea17c2d4109d4d43d59677c Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Wed, 27 Mar 2024 06:00:07 +0800
Subject: [PATCH 122/132] Update submodule cudf to
 e3cbf62fcef479a051d116c451e69ddaa4568b57 (#1902)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 23aad9ec76..e3cbf62fce 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 23aad9ec76ca0367be994a551a9b0a4838839883
+Subproject commit e3cbf62fcef479a051d116c451e69ddaa4568b57

From f94b894478b4af7036078dd0f0f42f5aa3f4c586 Mon Sep 17 00:00:00 2001
From: Tim Liu <timl@nvidia.com>
Date: Wed, 27 Mar 2024 19:35:57 +0800
Subject: [PATCH 123/132] Upate Git user for pre-merge CI (#1908)

Add user YanxuanLiu and remove pxLi

Signed-off-by: Tim Liu <timl@nvidia.com>
---
 .github/workflows/blossom-ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/blossom-ci.yml b/.github/workflows/blossom-ci.yml
index 5e4005462f..ece14b4201 100644
--- a/.github/workflows/blossom-ci.yml
+++ b/.github/workflows/blossom-ci.yml
@@ -55,7 +55,7 @@ jobs:
       wbo4958,\
       wjxiz1992,\
       sperlingxx,\
-      pxLi,\
+      YanxuanLiu,\
       hyperbolic2346,\
       gerashegalov,\
       ttnghia,\

From 87216f25dcc40988a21b3542f723e2478349ae8e Mon Sep 17 00:00:00 2001
From: Chong Gao <chongg@nvidia.com>
Date: Wed, 27 Mar 2024 23:39:54 +0800
Subject: [PATCH 124/132] New implementation of getJsonObject (#1893)

* get-json-object:  Add JSON parser and parser utility (#1836)

* Add Json Parser;
Add Json Parser utility;
Define internal interfaces;
Copy get-json-obj CUDA code from cuDF;

Signed-off-by: Chong Gao <res_life@163.com>

* Code format

---------

Signed-off-by: Chong Gao <res_life@163.com>
Co-authored-by: Chong Gao <res_life@163.com>

* get-json-object: match current field name (#1857)

Signed-off-by: Chong Gao <res_life@163.com>
Co-authored-by: Chong Gao <res_life@163.com>

* get-json-object: add utility write_escaped_text for JSON generator (#1863)

Signed-off-by: Chong Gao <res_life@163.com>
Co-authored-by: Chong Gao <res_life@163.com>

* Add JNI for GetJsonObject (#1862)

* Add JNI for GetJsonObject

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* clean up

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* Parse json path in plugin

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* Apply suggestions from code review

Co-authored-by: Nghia Truong <7416935+ttnghia@users.noreply.github.com>

* Use table_view

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* Update java

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* Apply suggestions from code review

Co-authored-by: Nghia Truong <7416935+ttnghia@users.noreply.github.com>

* clean up

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* use matched enum for type

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* clean up

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* upmerge

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* format

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

---------

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>
Co-authored-by: Nghia Truong <7416935+ttnghia@users.noreply.github.com>

* get-json-object: main flow (#1868)

Signed-off-by: Chong Gao <res_life@163.com>
Co-authored-by: Chong Gao <res_life@163.com>

* Optimize memory usage in match_current_field_name (#1889)

* Optimize match_current_field_name using less memory

Signed-off-by: Chong Gao <res_life@163.com>

* Convert a function to device code

* Add a JNI test case

* Add JNI test case

* Change nesting depth to 4

* Change nesting depth to 8 to fix test

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* remove clang format change

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

---------

Signed-off-by: Chong Gao <res_life@163.com>
Signed-off-by: Haoyang Li <haoyangl@nvidia.com>
Co-authored-by: Chong Gao <res_life@163.com>

* get-json-object: Recursive to iterative (#1890)

* Change recursive to iterative

Signed-off-by: Chong Gao <res_life@163.com>

---------

Signed-off-by: Chong Gao <res_life@163.com>
Co-authored-by: Chong Gao <res_life@163.com>

* Fix bug

* Format

* Use uppercase for path_instruction_type

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* Add test cases from Baidu

* Fix escape char error; add test case

* getJsonObject number normalization (#1897)

* Support number normalization

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* delete cpp test and add a java test case

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

---------

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* Add test case

* Fix a escape/unescape size bug

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* Fix bug: handle leading zeros for number; Refactor

* Apply suggestions from code review

Co-authored-by: Nghia Truong <7416935+ttnghia@users.noreply.github.com>

* Address comments

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* fix java test

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* Add test cases; Fix a bug

* follow up escape/unescape bug fix

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

* Minor refactor

* Add a case; Fix bug

---------

Signed-off-by: Chong Gao <res_life@163.com>
Signed-off-by: Haoyang Li <haoyangl@nvidia.com>
Co-authored-by: Chong Gao <res_life@163.com>
Co-authored-by: Haoyang Li <haoyangl@nvidia.com>
Co-authored-by: Nghia Truong <7416935+ttnghia@users.noreply.github.com>
---
 src/main/cpp/CMakeLists.txt                   |    2 +
 src/main/cpp/src/JSONUtilsJni.cpp             |   70 +
 src/main/cpp/src/ftos_converter.cuh           |  100 +-
 src/main/cpp/src/get_json_object.cu           |  331 +++
 src/main/cpp/src/get_json_object.hpp          | 1189 +++++++++++
 src/main/cpp/src/json_parser.hpp              | 1833 +++++++++++++++++
 .../nvidia/spark/rapids/jni/JSONUtils.java    |   53 +
 .../spark/rapids/jni/GetJsonObjectTest.java   |  602 ++++++
 8 files changed, 4161 insertions(+), 19 deletions(-)
 create mode 100644 src/main/cpp/src/JSONUtilsJni.cpp
 create mode 100644 src/main/cpp/src/get_json_object.cu
 create mode 100644 src/main/cpp/src/get_json_object.hpp
 create mode 100644 src/main/cpp/src/json_parser.hpp
 create mode 100644 src/main/java/com/nvidia/spark/rapids/jni/JSONUtils.java
 create mode 100644 src/test/java/com/nvidia/spark/rapids/jni/GetJsonObjectTest.java

diff --git a/src/main/cpp/CMakeLists.txt b/src/main/cpp/CMakeLists.txt
index 704a5a308b..1fef6ffab8 100644
--- a/src/main/cpp/CMakeLists.txt
+++ b/src/main/cpp/CMakeLists.txt
@@ -156,6 +156,7 @@ add_library(
   src/GpuTimeZoneDBJni.cpp
   src/HashJni.cpp
   src/HistogramJni.cpp
+  src/JSONUtilsJni.cpp
   src/MapUtilsJni.cpp
   src/NativeParquetJni.cpp
   src/ParseURIJni.cpp
@@ -170,6 +171,7 @@ add_library(
   src/cast_string_to_float.cu
   src/datetime_rebase.cu
   src/decimal_utils.cu
+  src/get_json_object.cu
   src/histogram.cu
   src/map_utils.cu
   src/murmur_hash.cu
diff --git a/src/main/cpp/src/JSONUtilsJni.cpp b/src/main/cpp/src/JSONUtilsJni.cpp
new file mode 100644
index 0000000000..73b932d4b9
--- /dev/null
+++ b/src/main/cpp/src/JSONUtilsJni.cpp
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "cudf_jni_apis.hpp"
+#include "get_json_object.hpp"
+
+#include <cudf/strings/strings_column_view.hpp>
+
+#include <vector>
+
+using path_instruction_type = spark_rapids_jni::path_instruction_type;
+
+extern "C" {
+JNIEXPORT jlong JNICALL Java_com_nvidia_spark_rapids_jni_JSONUtils_getJsonObject(
+  JNIEnv* env, jclass, jlong input_column, jobjectArray path_instructions)
+{
+  JNI_NULL_CHECK(env, input_column, "input column is null", 0);
+  JNI_NULL_CHECK(env, path_instructions, "path_instructions is null", 0);
+  try {
+    cudf::jni::auto_set_device(env);
+    auto const n_column_view      = reinterpret_cast<cudf::column_view const*>(input_column);
+    auto const n_strings_col_view = cudf::strings_column_view{*n_column_view};
+
+    std::vector<std::tuple<path_instruction_type, std::string, int64_t>> instructions;
+    int size = env->GetArrayLength(path_instructions);
+    for (int i = 0; i < size; i++) {
+      jobject instruction = env->GetObjectArrayElement(path_instructions, i);
+      JNI_NULL_CHECK(env, instruction, "path_instruction is null", 0);
+      jclass instruction_class = env->GetObjectClass(instruction);
+      JNI_NULL_CHECK(env, instruction_class, "instruction_class is null", 0);
+
+      jfieldID field_id = env->GetFieldID(instruction_class, "type", "I");
+      JNI_NULL_CHECK(env, field_id, "field_id is null", 0);
+      jint type                              = env->GetIntField(instruction, field_id);
+      path_instruction_type instruction_type = static_cast<path_instruction_type>(type);
+
+      field_id = env->GetFieldID(instruction_class, "name", "Ljava/lang/String;");
+      JNI_NULL_CHECK(env, field_id, "field_id is null", 0);
+      jstring name = (jstring)env->GetObjectField(instruction, field_id);
+      JNI_NULL_CHECK(env, name, "name is null", 0);
+      const char* name_str = env->GetStringUTFChars(name, JNI_FALSE);
+
+      field_id = env->GetFieldID(instruction_class, "index", "J");
+      JNI_NULL_CHECK(env, field_id, "field_id is null", 0);
+      jlong index = env->GetLongField(instruction, field_id);
+
+      instructions.emplace_back(instruction_type, name_str, index);
+
+      env->ReleaseStringUTFChars(name, name_str);
+    }
+
+    return cudf::jni::release_as_jlong(
+      spark_rapids_jni::get_json_object(n_strings_col_view, instructions));
+  }
+  CATCH_STD(env, 0);
+}
+}
diff --git a/src/main/cpp/src/ftos_converter.cuh b/src/main/cpp/src/ftos_converter.cuh
index c2fa07377c..f2e8ce0006 100644
--- a/src/main/cpp/src/ftos_converter.cuh
+++ b/src/main/cpp/src/ftos_converter.cuh
@@ -800,15 +800,15 @@ __device__ inline int to_chars(floating_decimal_64 const v, bool const sign, cha
   if (sign) { result[index++] = '-'; }
 
   uint64_t output         = v.mantissa;
-  uint32_t const olength  = decimal_length(output);
-  int32_t exp             = v.exponent + static_cast<int32_t>(olength) - 1;
+  int32_t const olength   = decimal_length(output);
+  int32_t exp             = v.exponent + olength - 1;
   bool scientificNotation = (exp < -3) || (exp >= 7);
 
   // Values in the interval [1E-3, 1E7) are special.
   if (scientificNotation) {
     // Print in the format x.xxxxxE-yy.
-    for (uint32_t i = 0; i < olength - 1; ++i) {
-      uint32_t const c = output % 10;
+    for (int i = 0; i < olength - 1; ++i) {
+      int const c = output % 10;
       output /= 10;
       result[index + olength - i] = (char)('0' + c);
     }
@@ -845,7 +845,7 @@ __device__ inline int to_chars(floating_decimal_64 const v, bool const sign, cha
         output /= 10;
         index++;
       }
-    } else if (exp + 1 >= olength) {
+    } else if (exp + 1 >= static_cast<int32_t>(olength)) {
       // Decimal dot is after any of the digits.
       for (int i = 0; i < olength; i++) {
         result[index + olength - i - 1] = (char)('0' + output % 10);
@@ -880,7 +880,7 @@ __device__ inline int d2s_size(floating_decimal_64 const v, bool const sign)
   if (sign) { index++; }
 
   uint64_t output         = v.mantissa;
-  uint32_t const olength  = decimal_length(output);
+  int32_t const olength   = decimal_length(output);
   int32_t exp             = v.exponent + static_cast<int32_t>(olength) - 1;
   bool scientificNotation = (exp < -3) || (exp >= 7);
 
@@ -920,7 +920,7 @@ __device__ inline int to_chars(floating_decimal_32 const v, bool const sign, cha
   if (sign) { result[index++] = '-'; }
 
   uint32_t output         = v.mantissa;
-  uint32_t const olength  = decimal_length(output);
+  int32_t const olength   = decimal_length(output);
   int32_t exp             = v.exponent + olength - 1;
   bool scientificNotation = (exp < -3) || (exp >= 7);
 
@@ -995,7 +995,7 @@ __device__ inline int f2s_size(floating_decimal_32 const v, bool const sign)
   if (sign) { index++; }
 
   uint32_t output         = v.mantissa;
-  uint32_t const olength  = decimal_length(output);
+  int32_t const olength   = decimal_length(output);
   int32_t exp             = v.exponent + olength - 1;
   bool scientificNotation = (exp < -3) || (exp >= 7);
 
@@ -1149,6 +1149,57 @@ __device__ inline int compute_f2s_size(float value)
   return f2s_size(v, sign);
 }
 
+//===== special inf handling for json =====
+
+__device__ inline int copy_special_str_json(char* const result,
+                                            bool const sign,
+                                            bool const exponent,
+                                            bool const mantissa)
+{
+  // no NaN in json
+  if (exponent) {
+    if (sign) {
+      memcpy(result, "\"-Infinity\"", 11);
+      return 11;
+    } else {
+      memcpy(result, "\"Infinity\"", 10);
+      return 10;
+    }
+  }
+  if (sign) {
+    memcpy(result, "-0.0", 4);
+    return 4;
+  } else {
+    memcpy(result, "0.0", 3);
+    return 3;
+  }
+}
+
+__device__ inline int special_str_size_json(bool const sign,
+                                            bool const exponent,
+                                            bool const mantissa)
+{
+  // no NaN in json
+  if (exponent) { return sign + 10; }
+  return sign + 3;
+}
+
+__device__ inline int d2s_buffered_n_json(double f, char* result)
+{
+  bool sign = false, special = false;
+  floating_decimal_64 v = d2d(f, sign, special);
+  if (special) { return copy_special_str_json(result, sign, v.exponent, v.mantissa); }
+  return to_chars(v, sign, result);
+}
+
+__device__ inline int compute_d2s_size_json(double value)
+{
+  bool sign = false, special = false;
+  floating_decimal_64 v = d2d(value, sign, special);
+  if (special) { return special_str_size_json(sign, v.exponent, v.mantissa); }
+  return d2s_size(v, sign);
+}
+
 }  // namespace
 
 //===== APIs =====
@@ -1223,9 +1274,9 @@ __device__ inline int to_formatted_chars(T const v, bool const sign, char* const
   using U   = std::conditional_t<std::is_same_v<T, floating_decimal_32>, uint32_t, uint64_t>;
   int index = 0;
   if (sign) { result[index++] = '-'; }
-  U output               = v.mantissa;
-  uint32_t const olength = decimal_length(output);
-  int32_t exp            = v.exponent + static_cast<int32_t>(olength) - 1;
+  U output              = v.mantissa;
+  int32_t const olength = decimal_length(output);
+  int32_t exp           = v.exponent + static_cast<int32_t>(olength) - 1;
   if (exp < 0) {
     // Decimal dot is before any of the digits.
     int index_for_carrier = index;
@@ -1291,7 +1342,7 @@ __device__ inline int to_formatted_chars(T const v, bool const sign, char* const
     }
   } else {
     // 0 <= exp < olength - 1
-    uint32_t temp_d = digits, tailing_zero = 0;
+    int32_t temp_d = digits, tailing_zero = 0;
     if (exp + digits + 1 > olength) {
       temp_d       = olength - exp - 1;
       tailing_zero = digits - temp_d;
@@ -1301,10 +1352,10 @@ __device__ inline int to_formatted_chars(T const v, bool const sign, char* const
     U integer        = rounded_output / pow10;
     U decimal        = rounded_output % pow10;
     // calculate integer length after format to cover carry case
-    uint32_t integer_len          = decimal_length(integer);
-    uint32_t formated_integer_len = index + integer_len + (integer_len - 1) / 3;
-    uint32_t sep_cnt              = 0;
-    int rev_index                 = 0;
+    int32_t integer_len          = decimal_length(integer);
+    int32_t formated_integer_len = index + integer_len + (integer_len - 1) / 3;
+    int32_t sep_cnt              = 0;
+    int rev_index                = 0;
     for (int i = 0; i < integer_len; i++) {
       if (sep_cnt == 3) {
         result[formated_integer_len - (rev_index++) - 1] = ',';
@@ -1338,9 +1389,9 @@ __device__ inline int format_size(T const v, bool const sign, int digits)
   using U   = std::conditional_t<std::is_same_v<T, floating_decimal_32>, uint32_t, uint64_t>;
   int index = 0;
   if (sign) { index++; }
-  U output               = v.mantissa;
-  uint32_t const olength = decimal_length(output);
-  int32_t exp            = v.exponent + static_cast<int32_t>(olength) - 1;
+  U output              = v.mantissa;
+  int32_t const olength = decimal_length(output);
+  int32_t exp           = v.exponent + static_cast<int32_t>(olength) - 1;
   if (exp < 0) {
     index += 2 + digits;
   } else if (exp + 1 >= olength) {
@@ -1424,4 +1475,15 @@ __device__ inline int format_float(double value, int digits, bool is_float, char
   }
 }
 
+//===== json_parser utility =====
+
+__device__ inline int double_normalization(double value, char* output)
+{
+  if (output == nullptr) {
+    return compute_d2s_size_json(value);
+  } else {
+    return d2s_buffered_n_json(value, output);
+  }
+}
+
 }  // namespace spark_rapids_jni::ftos_converter
diff --git a/src/main/cpp/src/get_json_object.cu b/src/main/cpp/src/get_json_object.cu
new file mode 100644
index 0000000000..e944337861
--- /dev/null
+++ b/src/main/cpp/src/get_json_object.cu
@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "get_json_object.hpp"
+
+#include <cudf/column/column_device_view.cuh>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/detail/copy.hpp>
+#include <cudf/detail/get_value.cuh>
+#include <cudf/detail/null_mask.hpp>
+#include <cudf/detail/offsets_iterator_factory.cuh>
+#include <cudf/detail/utilities/cuda.cuh>
+#include <cudf/detail/utilities/vector_factories.hpp>
+#include <cudf/json/json.hpp>
+#include <cudf/lists/list_device_view.cuh>
+#include <cudf/lists/lists_column_device_view.cuh>
+#include <cudf/scalar/scalar.hpp>
+#include <cudf/strings/detail/strings_children.cuh>
+#include <cudf/strings/detail/utilities.hpp>
+#include <cudf/strings/string_view.cuh>
+#include <cudf/strings/strings_column_view.hpp>
+#include <cudf/types.hpp>
+#include <cudf/utilities/bit.hpp>
+#include <cudf/utilities/default_stream.hpp>
+#include <cudf/utilities/error.hpp>
+#include <cudf/utilities/span.hpp>
+
+#include <rmm/device_uvector.hpp>
+#include <rmm/exec_policy.hpp>
+
+#include <thrust/optional.h>
+#include <thrust/pair.h>
+#include <thrust/scan.h>
+#include <thrust/tuple.h>
+
+namespace spark_rapids_jni {
+
+namespace detail {
+
+rmm::device_uvector<path_instruction> construct_path_commands(
+  std::vector<std::tuple<path_instruction_type, std::string, int64_t>> const& instructions,
+  cudf::string_scalar const& all_names_scalar,
+  rmm::cuda_stream_view stream,
+  rmm::mr::device_memory_resource* mr)
+{
+  int name_pos = 0;
+
+  // construct the path commands
+  std::vector<path_instruction> path_commands;
+  for (auto const& inst : instructions) {
+    auto const& [type, name, index] = inst;
+    switch (type) {
+      case path_instruction_type::SUBSCRIPT:
+        path_commands.emplace_back(path_instruction{path_instruction_type::SUBSCRIPT});
+        break;
+      case path_instruction_type::WILDCARD:
+        path_commands.emplace_back(path_instruction{path_instruction_type::WILDCARD});
+        break;
+      case path_instruction_type::KEY:
+        path_commands.emplace_back(path_instruction{path_instruction_type::KEY});
+        path_commands.back().name =
+          cudf::string_view(all_names_scalar.data() + name_pos, name.size());
+        name_pos += name.size();
+        break;
+      case path_instruction_type::INDEX:
+        path_commands.emplace_back(path_instruction{path_instruction_type::INDEX});
+        path_commands.back().index = index;
+        break;
+      case path_instruction_type::NAMED:
+        path_commands.emplace_back(path_instruction{path_instruction_type::NAMED});
+        path_commands.back().name =
+          cudf::string_view(all_names_scalar.data() + name_pos, name.size());
+        name_pos += name.size();
+        break;
+      default: CUDF_FAIL("Invalid path instruction type");
+    }
+  }
+  // convert to uvector
+  return cudf::detail::make_device_uvector_sync(path_commands, stream, mr);
+}
+
+/**
+ * @brief Parse a single json string using the provided command buffer
+ *
+ * @param j_parser The incoming json string and associated parser
+ * @param path_ptr The command buffer to be applied to the string.
+ * @param path_size Command buffer size
+ * @param output Buffer used to store the results of the query
+ * @returns A result code indicating success/fail/empty.
+ */
+__device__ inline bool parse_json_path(json_parser<>& j_parser,
+                                       path_instruction const* path_ptr,
+                                       size_t path_size,
+                                       json_generator<>& output)
+{
+  j_parser.next_token();
+  // JSON validation check
+  if (json_token::ERROR == j_parser.get_current_token()) { return false; }
+
+  return path_evaluator::evaluate_path(
+    j_parser, output, write_style::raw_style, path_ptr, path_size);
+}
+
+/**
+ * @brief Parse a single json string using the provided command buffer
+ *
+ *
+ * @param input The incoming json string
+ * @param input_len Size of the incoming json string
+ * @param path_commands_ptr The command buffer to be applied to the string.
+ * @param path_commands_size The command buffer size.
+ * @param out_buf Buffer user to store the results of the query
+ *                (nullptr in the size computation step)
+ * @param out_buf_size Size of the output buffer
+ * @returns A pair containing the result code and the output buffer.
+ */
+__device__ thrust::pair<bool, json_generator<>> get_json_object_single(
+  char const* input,
+  cudf::size_type input_len,
+  path_instruction const* path_commands_ptr,
+  int path_commands_size,
+  char* out_buf,
+  size_t out_buf_size)
+{
+  char* actual_output;
+  if (nullptr == out_buf) {
+    // First step: preprocess sizes
+    actual_output = out_buf;
+  } else {
+    // Second step: writes output
+    // if output buf size is zero, pass in nullptr to avoid generator writing trash output
+    actual_output = (0 == out_buf_size) ? nullptr : out_buf;
+  }
+
+  json_parser j_parser(input, input_len);
+  json_generator generator(actual_output);
+
+  if (!out_buf) {
+    // First step: preprocess sizes
+    bool success = parse_json_path(j_parser, path_commands_ptr, path_commands_size, generator);
+
+    if (!success) {
+      // generator may contain trash output, e.g.: generator writes some output,
+      // then JSON format is invalid, the previous output becomes trash.
+      // set output as zero to tell second step
+      generator.set_output_len_zero();
+    }
+    return {success, std::move(generator)};
+  } else {
+    // Second step: writes output
+    bool success = parse_json_path(j_parser, path_commands_ptr, path_commands_size, generator);
+    return {success, std::move(generator)};
+  }
+}
+
+/**
+ * @brief Kernel for running the JSONPath query.
+ *
+ * This kernel operates in a 2-pass way. On the first pass it computes the
+ * output sizes. On the second pass, it fills in the provided output buffers
+ * (chars and validity).
+ *
+ * @param col Device view of the incoming string
+ * @param commands JSONPath command buffer
+ * @param output_offsets Buffer used to store the string offsets for the results
+ *        of the query
+ * @param out_buf Buffer used to store the results of the query
+ * @param out_validity Output validity buffer
+ * @param out_valid_count Output count of # of valid bits
+ * @param options Options controlling behavior
+ */
+template <int block_size>
+__launch_bounds__(block_size) CUDF_KERNEL
+  void get_json_object_kernel(cudf::column_device_view col,
+                              path_instruction const* path_commands_ptr,
+                              int path_commands_size,
+                              cudf::size_type* d_sizes,
+                              cudf::detail::input_offsetalator output_offsets,
+                              char* out_buf,
+                              cudf::bitmask_type* out_validity,
+                              cudf::size_type* out_valid_count)
+{
+  auto tid          = cudf::detail::grid_1d::global_thread_id();
+  auto const stride = cudf::detail::grid_1d::grid_stride();
+
+  cudf::size_type warp_valid_count{0};
+
+  auto active_threads = __ballot_sync(0xffff'ffffu, tid < col.size());
+  while (tid < col.size()) {
+    bool is_valid               = false;
+    cudf::string_view const str = col.element<cudf::string_view>(tid);
+    cudf::size_type output_size = 0;
+    if (str.size_bytes() > 0) {
+      char* dst = out_buf != nullptr ? out_buf + output_offsets[tid] : nullptr;
+      size_t const dst_size =
+        out_buf != nullptr ? output_offsets[tid + 1] - output_offsets[tid] : 0;
+
+      // process one single row
+      auto [result, out] = get_json_object_single(
+        str.data(), str.size_bytes(), path_commands_ptr, path_commands_size, dst, dst_size);
+      output_size = out.get_output_len();
+      if (result) { is_valid = true; }
+    }
+
+    // filled in only during the precompute step. during the compute step, the
+    // offsets are fed back in so we do -not- want to write them out
+    if (out_buf == nullptr) { d_sizes[tid] = output_size; }
+
+    // validity filled in only during the output step
+    if (out_validity != nullptr) {
+      uint32_t mask = __ballot_sync(active_threads, is_valid);
+      // 0th lane of the warp writes the validity
+      if (!(tid % cudf::detail::warp_size)) {
+        out_validity[cudf::word_index(tid)] = mask;
+        warp_valid_count += __popc(mask);
+      }
+    }
+
+    tid += stride;
+    active_threads = __ballot_sync(active_threads, tid < col.size());
+  }
+
+  // sum the valid counts across the whole block
+  if (out_valid_count != nullptr) {
+    cudf::size_type block_valid_count =
+      cudf::detail::single_lane_block_sum_reduce<block_size, 0>(warp_valid_count);
+    if (threadIdx.x == 0) { atomicAdd(out_valid_count, block_valid_count); }
+  }
+}
+
+std::unique_ptr<cudf::column> get_json_object(
+  cudf::strings_column_view const& input,
+  std::vector<std::tuple<path_instruction_type, std::string, int64_t>> const& instructions,
+  rmm::cuda_stream_view stream,
+  rmm::mr::device_memory_resource* mr)
+{
+  if (input.is_empty()) return cudf::make_empty_column(cudf::type_id::STRING);
+
+  // get a string buffer to store all the names and convert to device
+  std::string all_names;
+  for (auto const& inst : instructions) {
+    all_names += std::get<1>(inst);
+  }
+  cudf::string_scalar all_names_scalar(all_names, true, stream);
+  // parse the json_path into a command buffer
+  auto path_commands = construct_path_commands(
+    instructions, all_names_scalar, stream, rmm::mr::get_current_device_resource());
+
+  // compute output sizes
+  auto sizes = rmm::device_uvector<cudf::size_type>(
+    input.size(), stream, rmm::mr::get_current_device_resource());
+  auto d_offsets = cudf::detail::offsetalator_factory::make_input_iterator(input.offsets());
+
+  constexpr int block_size = 512;
+  cudf::detail::grid_1d const grid{input.size(), block_size};
+  auto d_input_ptr = cudf::column_device_view::create(input.parent(), stream);
+  // preprocess sizes (returned in the offsets buffer)
+  get_json_object_kernel<block_size>
+    <<<grid.num_blocks, grid.num_threads_per_block, 0, stream.value()>>>(*d_input_ptr,
+                                                                         path_commands.data(),
+                                                                         path_commands.size(),
+                                                                         sizes.data(),
+                                                                         d_offsets,
+                                                                         nullptr,
+                                                                         nullptr,
+                                                                         nullptr);
+
+  // convert sizes to offsets
+  auto [offsets, output_size] =
+    cudf::strings::detail::make_offsets_child_column(sizes.begin(), sizes.end(), stream, mr);
+  d_offsets = cudf::detail::offsetalator_factory::make_input_iterator(offsets->view());
+
+  // allocate output string column
+  rmm::device_uvector<char> chars(output_size, stream, mr);
+
+  // potential optimization : if we know that all outputs are valid, we could
+  // skip creating the validity mask altogether
+  rmm::device_buffer validity =
+    cudf::detail::create_null_mask(input.size(), cudf::mask_state::UNINITIALIZED, stream, mr);
+
+  // compute results
+  rmm::device_scalar<cudf::size_type> d_valid_count{0, stream};
+
+  get_json_object_kernel<block_size>
+    <<<grid.num_blocks, grid.num_threads_per_block, 0, stream.value()>>>(
+      *d_input_ptr,
+      path_commands.data(),
+      path_commands.size(),
+      sizes.data(),
+      d_offsets,
+      chars.data(),
+      static_cast<cudf::bitmask_type*>(validity.data()),
+      d_valid_count.data());
+
+  auto result = make_strings_column(input.size(),
+                                    std::move(offsets),
+                                    chars.release(),
+                                    input.size() - d_valid_count.value(stream),
+                                    std::move(validity));
+  // unmatched array query may result in unsanitized '[' value in the result
+  if (auto const result_cv = result->view(); cudf::detail::has_nonempty_nulls(result_cv, stream)) {
+    result = cudf::detail::purge_nonempty_nulls(result_cv, stream, mr);
+  }
+  return result;
+}
+
+}  // namespace detail
+
+std::unique_ptr<cudf::column> get_json_object(
+  cudf::strings_column_view const& input,
+  std::vector<std::tuple<path_instruction_type, std::string, int64_t>> const& instructions,
+  rmm::cuda_stream_view stream,
+  rmm::mr::device_memory_resource* mr)
+{
+  return detail::get_json_object(input, instructions, stream, mr);
+}
+
+}  // namespace spark_rapids_jni
diff --git a/src/main/cpp/src/get_json_object.hpp b/src/main/cpp/src/get_json_object.hpp
new file mode 100644
index 0000000000..0522cabee5
--- /dev/null
+++ b/src/main/cpp/src/get_json_object.hpp
@@ -0,0 +1,1189 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "json_parser.hpp"
+
+#include <cudf/strings/string_view.hpp>
+#include <cudf/strings/strings_column_view.hpp>
+
+#include <thrust/optional.h>
+#include <thrust/pair.h>
+#include <thrust/scan.h>
+#include <thrust/tuple.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace spark_rapids_jni {
+
+/**
+ * path instruction type
+ */
+enum class path_instruction_type { SUBSCRIPT, WILDCARD, KEY, INDEX, NAMED };
+
+namespace detail {
+
+/**
+ * write JSON style
+ */
+enum class write_style { raw_style, quoted_style, flatten_style };
+
+/**
+ * path instruction
+ */
+struct path_instruction {
+  __device__ inline path_instruction(path_instruction_type _type) : type(_type) {}
+
+  path_instruction_type type;
+
+  // used when type is named type
+  cudf::string_view name;
+
+  // used when type is index
+  int index{-1};
+};
+
+/**
+ * JSON generator is used to write out JSON content.
+ * Because of get_json_object only outputs JSON object as a whole item,
+ * it's no need to store internal state for JSON object when outputing,
+ * only need to store internal state for JSON array.
+ */
+template <int max_json_nesting_depth = curr_max_json_nesting_depth>
+class json_generator {
+ public:
+  __device__ json_generator(char* _output) : output(_output), output_len(0) {}
+  __device__ json_generator() : output(nullptr), output_len(0) {}
+
+  __device__ json_generator<>& operator=(json_generator<> const& other)
+  {
+    this->output      = other.output;
+    this->output_len  = other.output_len;
+    this->array_depth = other.array_depth;
+    for (size_t i = 0; i < max_json_nesting_depth; i++) {
+      this->is_first_item[i] = other.is_first_item[i];
+    }
+
+    return *this;
+  }
+
+  // create a nested child generator based on this parent generator,
+  // child generator is a view, parent and child share the same byte array
+  __device__ json_generator new_child_generator()
+  {
+    if (nullptr == output) {
+      return json_generator();
+    } else {
+      return json_generator(output + output_len);
+    }
+  }
+
+  // write [
+  // add an extra comma if needed,
+  // e.g.: when JSON content is: [[1,2,3]
+  // writing a new [ should result: [[1,2,3],[
+  __device__ void write_start_array()
+  {
+    try_write_comma();
+
+    // update internal state
+    if (array_depth > 0) { is_first_item[array_depth - 1] = false; }
+
+    if (output) { *(output + output_len) = '['; }
+
+    output_len++;
+    is_first_item[array_depth] = true;
+    array_depth++;
+  }
+
+  // write ]
+  __device__ void write_end_array()
+  {
+    if (output) { *(output + output_len) = ']'; }
+    output_len++;
+    array_depth--;
+  }
+
+  // write first start array without output, only update internal state
+  __device__ void write_first_start_array_without_output()
+  {
+    // hide the outer start array token
+    // Note: do not inc output_len
+    is_first_item[array_depth] = true;
+    array_depth++;
+  }
+
+  // return true if it's in a array context and it's not writing the first item.
+  __device__ bool need_comma() { return (array_depth > 0 && !is_first_item[array_depth - 1]); }
+
+  /**
+   * write comma accroding to current generator state
+   */
+  __device__ void try_write_comma()
+  {
+    if (need_comma()) {
+      // in array context and writes first item
+      if (output) { *(output + output_len) = ','; }
+      output_len++;
+    }
+  }
+
+  /**
+   * copy current structure when parsing. If current token is start
+   * object/array, then copy to corresponding matched end object/array. return
+   * false if JSON format is invalid return true if JSON format is valid
+   */
+  __device__ bool copy_current_structure(json_parser<>& parser)
+  {
+    // first try add comma
+    try_write_comma();
+
+    if (array_depth > 0) { is_first_item[array_depth - 1] = false; }
+
+    if (nullptr != output) {
+      auto copy_to       = output + output_len;
+      auto [b, copy_len] = parser.copy_current_structure(copy_to);
+      output_len += copy_len;
+      return b;
+    } else {
+      char* copy_to      = nullptr;
+      auto [b, copy_len] = parser.copy_current_structure(copy_to);
+      output_len += copy_len;
+      return b;
+    }
+  }
+
+  /**
+   * Get current text from JSON parser and then write the text
+   * Note: Because JSON strings contains '\' to do escape,
+   * JSON parser should do unescape to remove '\' and JSON parser
+   * then can not return a pointer and length pair (char *, len),
+   * For number token, JSON parser can return a pair (char *, len)
+   */
+  __device__ void write_raw(json_parser<>& parser)
+  {
+    if (array_depth > 0) { is_first_item[array_depth - 1] = false; }
+
+    if (nullptr != output) {
+      auto copied = parser.write_unescaped_text(output + output_len);
+      output_len += copied;
+    } else {
+      auto len = parser.compute_unescaped_len();
+      output_len += len;
+    }
+  }
+
+  /**
+   * write child raw value
+   * e.g.:
+   *
+   * write_outer_array_tokens = false
+   * need_comma = true
+   * [1,2,3]1,2,3
+   *        ^
+   *        |
+   *    child pointer
+   * ==>>
+   * [1,2,3],1,2,3
+   *
+   *
+   * write_outer_array_tokens = true
+   * need_comma = true
+   *   [12,3,4
+   *     ^
+   *     |
+   * child pointer
+   * ==>>
+   *   [1,[2,3,4]
+   *
+   * For more information about param write_outer_array_tokens, refer to
+   * `write_first_start_array_without_output`
+   * @param child_block_begin
+   * @param child_block_len
+   * @param write_outer_array_tokens whether write outer array tokens for child block
+   */
+  __device__ void write_child_raw_value(char* child_block_begin,
+                                        size_t child_block_len,
+                                        bool write_outer_array_tokens)
+  {
+    bool insert_comma = need_comma();
+
+    is_first_item[array_depth - 1] = false;
+
+    if (nullptr != output) {
+      if (write_outer_array_tokens) {
+        if (insert_comma) {
+          *(child_block_begin + child_block_len + 2) = ']';
+          move_forward(child_block_begin, child_block_len, 2);
+          *(child_block_begin + 1) = '[';
+          *(child_block_begin)     = ',';
+        } else {
+          *(child_block_begin + child_block_len + 1) = ']';
+          move_forward(child_block_begin, child_block_len, 1);
+          *(child_block_begin) = '[';
+        }
+      } else {
+        if (insert_comma) {
+          move_forward(child_block_begin, child_block_len, 1);
+          *(child_block_begin) = ',';
+        } else {
+          // do not need comma && do not need write outer array tokens
+          // do nothing, because child generator buff is directly after the
+          // parent generator
+        }
+      }
+    }
+
+    // update length
+    if (insert_comma) { output_len++; }
+    if (write_outer_array_tokens) { output_len += 2; }
+    output_len += child_block_len;
+  }
+
+  // move memory block forward by specified bytes
+  // e.g.:  memory is: 1 2 0 0, begin is 1, len is 2, after moving,
+  // memory is: 1 2 1 2.
+  // e.g.:  memory is: 1 2 0 0, begin is 1, len is 1, after moving,
+  // memory is: 1 1 2 0.
+  // Note: should move from end to begin to avoid overwrite buffer
+  __device__ void move_forward(char* begin, size_t len, int forward)
+  {
+    char* pos = begin + len + forward - 1;
+    char* e   = begin + forward - 1;
+    while (pos > e) {
+      *pos = *(pos - forward);
+      pos--;
+    }
+  }
+
+  __device__ void reset() { output_len = 0; }
+
+  __device__ inline size_t get_output_len() const { return output_len; }
+  __device__ inline char* get_output_start_position() const { return output; }
+  __device__ inline char* get_current_output_position() const { return output + output_len; }
+
+  /**
+   * generator may contain trash output, e.g.: generator writes some output,
+   * then JSON format is invalid, the previous output becomes trash.
+   */
+  __device__ inline void set_output_len_zero() { output_len = 0; }
+
+  __device__ inline void set_output_len(size_t len) { output_len = len; }
+
+ private:
+  char* output;
+  size_t output_len;
+
+  bool is_first_item[max_json_nesting_depth];
+  int array_depth = 0;
+};
+
+/**
+ * path evaluator which can run on both CPU and GPU
+ */
+struct path_evaluator {
+  static __device__ inline bool path_is_empty(size_t path_size) { return path_size == 0; }
+
+  static __device__ inline bool path_match_element(path_instruction const* path_ptr,
+                                                   size_t path_size,
+                                                   path_instruction_type path_type0)
+  {
+    if (path_size < 1) { return false; }
+    return path_ptr[0].type == path_type0;
+  }
+
+  static __device__ inline bool path_match_elements(path_instruction const* path_ptr,
+                                                    size_t path_size,
+                                                    path_instruction_type path_type0,
+                                                    path_instruction_type path_type1)
+  {
+    if (path_size < 2) { return false; }
+    return path_ptr[0].type == path_type0 && path_ptr[1].type == path_type1;
+  }
+
+  static __device__ inline bool path_match_elements(path_instruction const* path_ptr,
+                                                    size_t path_size,
+                                                    path_instruction_type path_type0,
+                                                    path_instruction_type path_type1,
+                                                    path_instruction_type path_type2,
+                                                    path_instruction_type path_type3)
+  {
+    if (path_size < 4) { return false; }
+    return path_ptr[0].type == path_type0 && path_ptr[1].type == path_type1 &&
+           path_ptr[2].type == path_type2 && path_ptr[3].type == path_type3;
+  }
+
+  static __device__ inline thrust::tuple<bool, int> path_match_subscript_index(
+    path_instruction const* path_ptr, size_t path_size)
+  {
+    auto match = path_match_elements(
+      path_ptr, path_size, path_instruction_type::SUBSCRIPT, path_instruction_type::INDEX);
+    if (match) {
+      return thrust::make_tuple(true, path_ptr[1].index);
+    } else {
+      return thrust::make_tuple(false, 0);
+    }
+  }
+
+  static __device__ inline thrust::tuple<bool, cudf::string_view> path_match_named(
+    path_instruction const* path_ptr, size_t path_size)
+  {
+    auto match = path_match_element(path_ptr, path_size, path_instruction_type::NAMED);
+    if (match) {
+      return thrust::make_tuple(true, path_ptr[0].name);
+    } else {
+      return thrust::make_tuple(false, cudf::string_view());
+    }
+  }
+
+  static __device__ inline thrust::tuple<bool, int> path_match_subscript_index_subscript_wildcard(
+    path_instruction const* path_ptr, size_t path_size)
+  {
+    auto match = path_match_elements(path_ptr,
+                                     path_size,
+                                     path_instruction_type::SUBSCRIPT,
+                                     path_instruction_type::INDEX,
+                                     path_instruction_type::SUBSCRIPT,
+                                     path_instruction_type::WILDCARD);
+    if (match) {
+      return thrust::make_tuple(true, path_ptr[1].index);
+    } else {
+      return thrust::make_tuple(false, 0);
+    }
+  }
+
+  /**
+   *
+   * The following commented function is recursive version,
+   * The next function below is the rewritten version,
+   * Keep version here is for review purpuse, because rewritten version(iterative)
+   * is not human friendly.
+   *
+   */
+  // static __device__ bool evaluate_path(json_parser<>& p,
+  //                                            json_generator<>& g,
+  //                                            write_style style,
+  //                                            path_instruction const* path_ptr,
+  //                                            int path_size)
+  // {
+  //   auto token = p.get_current_token();
+
+  //   // case (VALUE_STRING, Nil) if style == RawStyle
+  //   // case path 1
+  //   if (json_token::VALUE_STRING == token && path_is_empty(path_size) &&
+  //       style == write_style::raw_style) {
+  //     // there is no array wildcard or slice parent, emit this string without
+  //     // quotes write current string in parser to generator
+  //     g.write_raw(p);
+  //     return true;
+  //   }
+  //   // case (START_ARRAY, Nil) if style == FlattenStyle
+  //   // case path 2
+  //   else if (json_token::START_ARRAY == token && path_is_empty(path_size) &&
+  //            style == write_style::flatten_style) {
+  //     // flatten this array into the parent
+  //     bool dirty = false;
+  //     while (json_token::END_ARRAY != p.next_token()) {
+  //       // JSON validation check
+  //       if (json_token::ERROR == p.get_current_token()) { return false; }
+
+  //       dirty |= path_evaluator::evaluate_path(p, g, style, nullptr, 0);
+  //     }
+  //     return dirty;
+  //   }
+  //   // case (_, Nil)
+  //   // case path 3
+  //   else if (path_is_empty(path_size)) {
+  //     // general case: just copy the child tree verbatim
+  //     return g.copy_current_structure(p);
+  //   }
+  //   // case (START_OBJECT, Key :: xs)
+  //   // case path 4
+  //   else if (json_token::START_OBJECT == token &&
+  //            path_match_element(path_ptr, path_size, path_instruction_type::KEY)) {
+  //     bool dirty = false;
+  //     while (json_token::END_OBJECT != p.next_token()) {
+  //       // JSON validation check
+  //       if (json_token::ERROR == p.get_current_token()) { return false; }
+
+  //       if (dirty) {
+  //         // once a match has been found we can skip other fields
+  //         if (!p.try_skip_children()) {
+  //           // JSON validation check
+  //           return false;
+  //         }
+  //       } else {
+  //         dirty = path_evaluator::evaluate_path(p, g, style, path_ptr + 1, path_size - 1);
+  //       }
+  //     }
+  //     return dirty;
+  //   }
+  //   // case (START_ARRAY, Subscript :: Wildcard :: Subscript :: Wildcard :: xs)
+  //   // case path 5
+  //   else if (json_token::START_ARRAY == token &&
+  //            path_match_elements(path_ptr,
+  //                                path_size,
+  //                                path_instruction_type::SUBSCRIPT,
+  //                                path_instruction_type::WILDCARD,
+  //                                path_instruction_type::SUBSCRIPT,
+  //                                path_instruction_type::WILDCARD)) {
+  //     // special handling for the non-structure preserving double wildcard
+  //     // behavior in Hive
+  //     bool dirty = false;
+  //     g.write_start_array();
+  //     while (p.next_token() != json_token::END_ARRAY) {
+  //       // JSON validation check
+  //       if (json_token::ERROR == p.get_current_token()) { return false; }
+
+  //       dirty |= path_evaluator::evaluate_path(
+  //         p, g, write_style::flatten_style, path_ptr + 4, path_size - 4);
+  //     }
+  //     g.write_end_array();
+  //     return dirty;
+  //   }
+  //   // case (START_ARRAY, Subscript :: Wildcard :: xs) if style != QuotedStyle
+  //   // case path 6
+  //   else if (json_token::START_ARRAY == token &&
+  //            path_match_elements(path_ptr,
+  //                                path_size,
+  //                                path_instruction_type::SUBSCRIPT,
+  //                                path_instruction_type::WILDCARD) &&
+  //            style != write_style::quoted_style) {
+  //     // retain Flatten, otherwise use Quoted... cannot use Raw within an array
+  //     write_style next_style = write_style::raw_style;
+  //     switch (style) {
+  //       case write_style::raw_style: next_style = write_style::quoted_style; break;
+  //       case write_style::flatten_style: next_style = write_style::flatten_style; break;
+  //       case write_style::quoted_style: next_style = write_style::quoted_style;  // never happen
+  //     }
+
+  //     // temporarily buffer child matches, the emitted json will need to be
+  //     // modified slightly if there is only a single element written
+
+  //     int dirty = 0;
+  //     // create a child generator with hide outer array tokens mode.
+  //     auto child_g = g.new_child_generator(/*hide_outer_array_tokens*/ true);
+
+  //     // Note: child generator does not actually write the outer start array
+  //     // token into buffer it only updates internal nested state
+  //     child_g.write_start_array();
+
+  //     while (p.next_token() != json_token::END_ARRAY) {
+  //       // JSON validation check
+  //       if (json_token::ERROR == p.get_current_token()) { return false; }
+
+  //       // track the number of array elements and only emit an outer array if
+  //       // we've written more than one element, this matches Hive's behavior
+  //       dirty +=
+  //         (path_evaluator::evaluate_path(p, child_g, next_style, path_ptr + 2, path_size - 2) ? 1
+  //                                                                                             :
+  //                                                                                             0);
+  //     }
+
+  //     // Note: child generator does not actually write the outer end array token
+  //     // into buffer it only updates internal nested state
+  //     child_g.write_end_array();
+
+  //     char* child_g_start = child_g.get_output_start_position();
+  //     size_t child_g_len  = child_g.get_output_len();  // len already excluded outer [ ]
+
+  //     if (dirty > 1) {
+  //       // add outer array tokens
+  //       g.write_child_raw_value(child_g_start, child_g_len, true);
+  //     } else if (dirty == 1) {
+  //       // remove outer array tokens
+  //       g.write_child_raw_value(child_g_start, child_g_len, false);
+  //     }  // else do not write anything
+
+  //     return dirty > 0;
+  //   }
+  //   // case (START_ARRAY, Subscript :: Wildcard :: xs)
+  //   // case path 7
+  //   else if (json_token::START_ARRAY == token &&
+  //            path_match_elements(path_ptr,
+  //                                path_size,
+  //                                path_instruction_type::SUBSCRIPT,
+  //                                path_instruction_type::WILDCARD)) {
+  //     bool dirty = false;
+  //     g.write_start_array();
+  //     while (p.next_token() != json_token::END_ARRAY) {
+  //       // JSON validation check
+  //       if (json_token::ERROR == p.get_current_token()) { return false; }
+
+  //       // wildcards can have multiple matches, continually update the dirty
+  //       // count
+  //       dirty |= path_evaluator::evaluate_path(
+  //         p, g, write_style::quoted_style, path_ptr + 2, path_size - 2);
+  //     }
+  //     g.write_end_array();
+
+  //     return dirty;
+  //   }
+  //   /* case (START_ARRAY, Subscript :: Index(idx) :: (xs@Subscript :: Wildcard :: _)) */
+  //   // case path 8
+  //   else if (json_token::START_ARRAY == token &&
+  //            thrust::get<0>(path_match_subscript_index_subscript_wildcard(path_ptr, path_size)))
+  //            {
+  //     int idx = thrust::get<1>(path_match_subscript_index_subscript_wildcard(path_ptr,
+  //     path_size)); p.next_token();
+  //     // JSON validation check
+  //     if (json_token::ERROR == p.get_current_token()) { return false; }
+
+  //     int i = idx;
+  //     while (i >= 0) {
+  //       if (p.get_current_token() == json_token::END_ARRAY) {
+  //         // terminate, nothing has been written
+  //         return false;
+  //       }
+  //       if (0 == i) {
+  //         bool dirty = path_evaluator::evaluate_path(
+  //           p, g, write_style::quoted_style, path_ptr + 2, path_size - 2);
+  //         while (p.next_token() != json_token::END_ARRAY) {
+  //           // JSON validation check
+  //           if (json_token::ERROR == p.get_current_token()) { return false; }
+
+  //           // advance the token stream to the end of the array
+  //           if (!p.try_skip_children()) { return false; }
+  //         }
+  //         return dirty;
+  //       } else {
+  //         // i > 0
+  //         if (!p.try_skip_children()) { return false; }
+
+  //         p.next_token();
+  //         // JSON validation check
+  //         if (json_token::ERROR == p.get_current_token()) { return false; }
+  //       }
+  //       --i;
+  //     }
+  //     // path parser guarantees idx >= 0
+  //     // will never reach to here
+  //     return false;
+  //   }
+  //   // case (START_ARRAY, Subscript :: Index(idx) :: xs)
+  //   // case path 9
+  //   else if (json_token::START_ARRAY == token &&
+  //            thrust::get<0>(path_match_subscript_index(path_ptr, path_size))) {
+  //     int idx = thrust::get<1>(path_match_subscript_index(path_ptr, path_size));
+  //     p.next_token();
+  //     // JSON validation check
+  //     if (json_token::ERROR == p.get_current_token()) { return false; }
+
+  //     int i = idx;
+  //     while (i >= 0) {
+  //       if (p.get_current_token() == json_token::END_ARRAY) {
+  //         // terminate, nothing has been written
+  //         return false;
+  //       }
+  //       if (0 == i) {
+  //         bool dirty = path_evaluator::evaluate_path(p, g, style, path_ptr + 2, path_size - 2);
+  //         while (p.next_token() != json_token::END_ARRAY) {
+  //           // JSON validation check
+  //           if (json_token::ERROR == p.get_current_token()) { return false; }
+
+  //           // advance the token stream to the end of the array
+  //           if (!p.try_skip_children()) { return false; }
+  //         }
+  //         return dirty;
+  //       } else {
+  //         // i > 0
+  //         if (!p.try_skip_children()) { return false; }
+
+  //         p.next_token();
+  //         // JSON validation check
+  //         if (json_token::ERROR == p.get_current_token()) { return false; }
+  //       }
+  //       --i;
+  //     }
+  //     // path parser guarantees idx >= 0
+  //     // will never reach to here
+  //     return false;
+  //   }
+  //   // case (FIELD_NAME, Named(name) :: xs) if p.getCurrentName == name
+  //   // case path 10
+  //   else if (json_token::FIELD_NAME == token &&
+  //            thrust::get<0>(path_match_named(path_ptr, path_size)) &&
+  //            p.match_current_field_name(thrust::get<1>(path_match_named(path_ptr, path_size)))) {
+  //     if (p.next_token() != json_token::VALUE_NULL) {
+  //       // JSON validation check
+  //       if (json_token::ERROR == p.get_current_token()) { return false; }
+
+  //       return path_evaluator::evaluate_path(p, g, style, path_ptr + 1, path_size - 1);
+  //     } else {
+  //       return false;
+  //     }
+  //   }
+  //   // case (FIELD_NAME, Wildcard :: xs)
+  //   // case path 11
+  //   else if (json_token::FIELD_NAME == token &&
+  //            path_match_element(path_ptr, path_size, path_instruction_type::WILDCARD)) {
+  //     p.next_token();
+  //     // JSON validation check
+  //     if (json_token::ERROR == p.get_current_token()) { return false; }
+
+  //     return path_evaluator::evaluate_path(p, g, style, path_ptr + 1, path_size - 1);
+  //   }
+  //   // case _ =>
+  //   // case path 12
+  //   else {
+  //     if (!p.try_skip_children()) { return false; }
+  //     return false;
+  //   }
+  // }
+
+  /**
+   *
+   * This function is rewritten from above commented recursive function.
+   * this function is equivalent to the above commented recursive function.
+   */
+  static __device__ bool evaluate_path(json_parser<>& p,
+                                       json_generator<>& root_g,
+                                       write_style root_style,
+                                       path_instruction const* root_path_ptr,
+                                       int root_path_size)
+  {
+    // manually maintained context stack in lieu of calling evaluate_path recursively.
+    struct context {
+      // current token
+      json_token token;
+
+      // which case path that this task is from
+      int case_path;
+
+      // used to save current generator
+      json_generator<> g;
+
+      write_style style;
+      path_instruction const* path_ptr;
+      int path_size;
+
+      // is this context task is done
+      bool task_is_done = false;
+
+      // whether written output
+      // if dirty > 0, indicates success
+      int dirty = 0;
+
+      // for some case paths
+      bool is_first_enter = true;
+
+      // used to save child JSON generator for case path 8
+      json_generator<> child_g;
+
+      __device__ context()
+        : token(json_token::INIT),
+          case_path(-1),
+          g(json_generator<>()),
+          style(write_style::raw_style),
+          path_ptr(nullptr),
+          path_size(0)
+      {
+      }
+
+      __device__ context(json_token _token,
+                         int _case_path,
+                         json_generator<> _g,
+                         write_style _style,
+                         path_instruction const* _path_ptr,
+                         int _path_size)
+        : token(_token),
+          case_path(_case_path),
+          g(_g),
+          style(_style),
+          path_ptr(_path_ptr),
+          path_size(_path_size)
+      {
+      }
+
+      __device__ context& operator=(context const&) = default;
+    };
+
+    // path max depth limitation
+    constexpr int max_path_depth = 32;
+
+    // stack
+    context stack[max_path_depth];
+    int stack_pos = 0;
+
+    // push context function
+    auto push_context = [&stack, &stack_pos](json_token _token,
+                                             int _case_path,
+                                             json_generator<> _g,
+                                             write_style _style,
+                                             path_instruction const* _path_ptr,
+                                             int _path_size) {
+      if (stack_pos == max_path_depth - 1) { return false; }
+      stack[stack_pos++] = context(_token, _case_path, _g, _style, _path_ptr, _path_size);
+      return true;
+    };
+
+    // push context function
+    auto push_ctx = [&stack, &stack_pos](context ctx) {
+      if (stack_pos == max_path_depth - 1) { return false; }
+      stack[stack_pos++] = ctx;
+      return true;
+    };
+
+    // pop context function
+    auto pop_context = [&stack, &stack_pos](context& c) {
+      if (stack_pos > 0) {
+        c = stack[--stack_pos];
+        return true;
+      }
+      return false;
+    };
+
+    // put the first context task
+    push_context(p.get_current_token(), -1, root_g, root_style, root_path_ptr, root_path_size);
+
+    // current context task
+    context ctx;
+
+    // parent context task
+    context p_ctx;
+
+    while (pop_context(ctx)) {
+      if (!ctx.task_is_done) {
+        // task is not done.
+
+        // case (VALUE_STRING, Nil) if style == RawStyle
+        // case path 1
+        if (json_token::VALUE_STRING == ctx.token && path_is_empty(ctx.path_size) &&
+            ctx.style == write_style::raw_style) {
+          // there is no array wildcard or slice parent, emit this string without
+          // quotes write current string in parser to generator
+          ctx.g.write_raw(p);
+          ctx.dirty        = 1;
+          ctx.task_is_done = true;
+          push_ctx(ctx);
+        }
+        // case (START_ARRAY, Nil) if style == FlattenStyle
+        // case path 2
+        else if (json_token::START_ARRAY == ctx.token && path_is_empty(ctx.path_size) &&
+                 ctx.style == write_style::flatten_style) {
+          // flatten this array into the parent
+          if (json_token::END_ARRAY != p.next_token()) {
+            // JSON validation check
+            if (json_token::ERROR == p.get_current_token()) { return false; }
+            // push back task
+            push_ctx(ctx);
+            // add child task
+            push_context(p.get_current_token(), 2, ctx.g, ctx.style, nullptr, 0);
+          } else {
+            // END_ARRAY
+            ctx.task_is_done = true;
+            push_ctx(ctx);
+          }
+        }
+        // case (_, Nil)
+        // case path 3
+        else if (path_is_empty(ctx.path_size)) {
+          // general case: just copy the child tree verbatim
+          if (!(ctx.g.copy_current_structure(p))) {
+            // JSON validation check
+            return false;
+          }
+          ctx.dirty        = 1;
+          ctx.task_is_done = true;
+          push_ctx(ctx);
+        }
+        // case (START_OBJECT, Key :: xs)
+        // case path 4
+        else if (json_token::START_OBJECT == ctx.token &&
+                 path_match_element(ctx.path_ptr, ctx.path_size, path_instruction_type::KEY)) {
+          if (json_token::END_OBJECT != p.next_token()) {
+            // JSON validation check
+            if (json_token::ERROR == p.get_current_token()) { return false; }
+
+            if (ctx.dirty > 0) {
+              // once a match has been found we can skip other fields
+              if (!p.try_skip_children()) {
+                // JSON validation check
+                return false;
+              }
+              push_ctx(ctx);
+            } else {
+              // need to try more children
+              push_ctx(ctx);
+              push_context(
+                p.get_current_token(), 4, ctx.g, ctx.style, ctx.path_ptr + 1, ctx.path_size - 1);
+            }
+          } else {
+            ctx.task_is_done = true;
+            push_ctx(ctx);
+          }
+        }
+        // case (START_ARRAY, Subscript :: Wildcard :: Subscript :: Wildcard :: xs)
+        // case path 5
+        else if (json_token::START_ARRAY == ctx.token &&
+                 path_match_elements(ctx.path_ptr,
+                                     ctx.path_size,
+                                     path_instruction_type::SUBSCRIPT,
+                                     path_instruction_type::WILDCARD,
+                                     path_instruction_type::SUBSCRIPT,
+                                     path_instruction_type::WILDCARD)) {
+          // special handling for the non-structure preserving double wildcard
+          // behavior in Hive
+          if (ctx.is_first_enter) {
+            ctx.is_first_enter = false;
+            ctx.g.write_start_array();
+          }
+
+          if (p.next_token() != json_token::END_ARRAY) {
+            // JSON validation check
+            if (json_token::ERROR == p.get_current_token()) { return false; }
+            push_ctx(ctx);
+            push_context(p.get_current_token(),
+                         5,
+                         ctx.g,
+                         write_style::flatten_style,
+                         ctx.path_ptr + 4,
+                         ctx.path_size - 4);
+          } else {
+            ctx.g.write_end_array();
+            ctx.task_is_done = true;
+            push_ctx(ctx);
+          }
+        }
+        // case (START_ARRAY, Subscript :: Wildcard :: xs) if style != QuotedStyle
+        // case path 6
+        else if (json_token::START_ARRAY == ctx.token &&
+                 path_match_elements(ctx.path_ptr,
+                                     ctx.path_size,
+                                     path_instruction_type::SUBSCRIPT,
+                                     path_instruction_type::WILDCARD) &&
+                 ctx.style != write_style::quoted_style) {
+          // retain Flatten, otherwise use Quoted... cannot use Raw within an array
+          write_style next_style = write_style::raw_style;
+          switch (ctx.style) {
+            case write_style::raw_style: next_style = write_style::quoted_style; break;
+            case write_style::flatten_style: next_style = write_style::flatten_style; break;
+            case write_style::quoted_style: next_style = write_style::quoted_style;  // never happen
+          }
+
+          // temporarily buffer child matches, the emitted json will need to be
+          // modified slightly if there is only a single element written
+
+          json_generator<> child_g;
+          if (ctx.is_first_enter) {
+            ctx.is_first_enter = false;
+            // create a child generator with hide outer array tokens mode.
+            child_g = ctx.g.new_child_generator();
+            // write first [ without output, without update len, only update internal state
+            child_g.write_first_start_array_without_output();
+          } else {
+            child_g = ctx.child_g;
+          }
+
+          if (p.next_token() != json_token::END_ARRAY) {
+            // JSON validation check
+            if (json_token::ERROR == p.get_current_token()) { return false; }
+
+            push_ctx(ctx);
+            // track the number of array elements and only emit an outer array if
+            // we've written more than one element, this matches Hive's behavior
+            push_context(
+              p.get_current_token(), 6, child_g, next_style, ctx.path_ptr + 2, ctx.path_size - 2);
+          } else {
+            char* child_g_start = child_g.get_output_start_position();
+            size_t child_g_len  = child_g.get_output_len();
+
+            if (ctx.dirty > 1) {
+              // add outer array tokens
+              ctx.g.write_child_raw_value(
+                child_g_start, child_g_len, /* write_outer_array_tokens */ true);
+              ctx.task_is_done = true;
+              push_ctx(ctx);
+            } else if (ctx.dirty == 1) {
+              // remove outer array tokens
+              ctx.g.write_child_raw_value(
+                child_g_start, child_g_len, /* write_outer_array_tokens */ false);
+              ctx.task_is_done = true;
+              push_ctx(ctx);
+            }  // else do not write anything
+          }
+        }
+        // case (START_ARRAY, Subscript :: Wildcard :: xs)
+        // case path 7
+        else if (json_token::START_ARRAY == ctx.token &&
+                 path_match_elements(ctx.path_ptr,
+                                     ctx.path_size,
+                                     path_instruction_type::SUBSCRIPT,
+                                     path_instruction_type::WILDCARD)) {
+          if (ctx.is_first_enter) {
+            ctx.is_first_enter = false;
+            ctx.g.write_start_array();
+          }
+
+          if (p.next_token() != json_token::END_ARRAY) {
+            // JSON validation check
+            if (json_token::ERROR == p.get_current_token()) { return false; }
+
+            // wildcards can have multiple matches, continually update the dirty
+            // count
+            push_ctx(ctx);
+            push_context(p.get_current_token(),
+                         7,
+                         ctx.g,
+                         write_style::quoted_style,
+                         ctx.path_ptr + 2,
+                         ctx.path_size - 2);
+          } else {
+            ctx.g.write_end_array();
+            ctx.task_is_done = true;
+            push_ctx(ctx);
+          }
+        }
+        /* case (START_ARRAY, Subscript :: Index(idx) :: (xs@Subscript :: Wildcard :: _)) */
+        // case path 8
+        else if (json_token::START_ARRAY == ctx.token &&
+                 thrust::get<0>(
+                   path_match_subscript_index_subscript_wildcard(ctx.path_ptr, ctx.path_size))) {
+          int idx = thrust::get<1>(
+            path_match_subscript_index_subscript_wildcard(ctx.path_ptr, ctx.path_size));
+
+          p.next_token();
+          // JSON validation check
+          if (json_token::ERROR == p.get_current_token()) { return false; }
+          ctx.is_first_enter = false;
+
+          int i = idx;
+          while (i > 0) {
+            if (p.get_current_token() == json_token::END_ARRAY) {
+              // terminate, nothing has been written
+              return false;
+            }
+
+            if (!p.try_skip_children()) { return false; }
+
+            p.next_token();
+            // JSON validation check
+            if (json_token::ERROR == p.get_current_token()) { return false; }
+
+            --i;
+          }
+
+          // i == 0
+          push_ctx(ctx);
+          push_context(p.get_current_token(),
+                       8,
+                       ctx.g,
+                       write_style::quoted_style,
+                       ctx.path_ptr + 2,
+                       ctx.path_size - 2);
+        }
+        // case (START_ARRAY, Subscript :: Index(idx) :: xs)
+        // case path 9
+        else if (json_token::START_ARRAY == ctx.token &&
+                 thrust::get<0>(path_match_subscript_index(ctx.path_ptr, ctx.path_size))) {
+          int idx = thrust::get<1>(path_match_subscript_index(ctx.path_ptr, ctx.path_size));
+
+          p.next_token();
+          // JSON validation check
+          if (json_token::ERROR == p.get_current_token()) { return false; }
+
+          int i = idx;
+          while (i > 0) {
+            if (p.get_current_token() == json_token::END_ARRAY) {
+              // terminate, nothing has been written
+              return false;
+            }
+
+            if (!p.try_skip_children()) { return false; }
+
+            p.next_token();
+            // JSON validation check
+            if (json_token::ERROR == p.get_current_token()) { return false; }
+
+            --i;
+          }
+
+          // i == 0
+          push_ctx(ctx);
+          push_context(
+            p.get_current_token(), 9, ctx.g, ctx.style, ctx.path_ptr + 2, ctx.path_size - 2);
+        }
+        // case (FIELD_NAME, Named(name) :: xs) if p.getCurrentName == name
+        // case path 10
+        else if (json_token::FIELD_NAME == ctx.token &&
+                 thrust::get<0>(path_match_named(ctx.path_ptr, ctx.path_size)) &&
+                 p.match_current_field_name(
+                   thrust::get<1>(path_match_named(ctx.path_ptr, ctx.path_size)))) {
+          if (p.next_token() != json_token::VALUE_NULL) {
+            // JSON validation check
+            if (json_token::ERROR == p.get_current_token()) { return false; }
+            push_ctx(ctx);
+            push_context(
+              p.get_current_token(), 10, ctx.g, ctx.style, ctx.path_ptr + 1, ctx.path_size - 1);
+          } else {
+            return false;
+          }
+        }
+        // case (FIELD_NAME, Wildcard :: xs)
+        // case path 11
+        else if (json_token::FIELD_NAME == ctx.token &&
+                 path_match_element(ctx.path_ptr, ctx.path_size, path_instruction_type::WILDCARD)) {
+          p.next_token();
+          // JSON validation check
+          if (json_token::ERROR == p.get_current_token()) { return false; }
+          push_ctx(ctx);
+          push_context(
+            p.get_current_token(), 11, ctx.g, ctx.style, ctx.path_ptr + 1, ctx.path_size - 1);
+        }
+        // case _ =>
+        // case path 12
+        else {
+          if (!p.try_skip_children()) { return false; }
+          // default case path, return false for this task
+          ctx.dirty        = 0;
+          ctx.task_is_done = true;
+          push_ctx(ctx);
+        }
+      } else {
+        // current context is done.
+
+        // pop parent task
+        // update parent task info according to current task result
+        if (pop_context(p_ctx)) {
+          // case (VALUE_STRING, Nil) if style == RawStyle
+          // case path 1
+          if (1 == ctx.case_path) {
+            // never happen
+          }
+          // case (START_ARRAY, Nil) if style == FlattenStyle
+          // case path 2
+          else if (2 == ctx.case_path) {
+            // collect result from child task
+            p_ctx.dirty += ctx.dirty;
+            // copy generator states to parent task;
+            p_ctx.g = ctx.g;
+            push_ctx(p_ctx);
+          }
+          // case (_, Nil)
+          // case path 3
+          else if (3 == ctx.case_path) {
+            // never happen
+          }
+          // case (START_OBJECT, Key :: xs)
+          // case path 4
+          else if (4 == ctx.case_path) {
+            if (p_ctx.dirty < 1 && ctx.dirty > 0) { p_ctx.dirty = ctx.dirty; }
+            // copy generator states to parent task;
+            p_ctx.g = ctx.g;
+            push_ctx(p_ctx);
+          }
+          // case (START_ARRAY, Subscript :: Wildcard :: Subscript :: Wildcard :: xs)
+          // case path 5
+          else if (5 == ctx.case_path) {
+            // collect result from child task
+            p_ctx.dirty += ctx.dirty;
+            // copy generator states to parent task;
+            p_ctx.g = ctx.g;
+            push_ctx(p_ctx);
+          }
+          // case (START_ARRAY, Subscript :: Wildcard :: xs) if style != QuotedStyle
+          // case path 6
+          else if (6 == ctx.case_path) {
+            // collect result from child task
+            p_ctx.dirty += ctx.dirty;
+            // update child generator for parent task
+            p_ctx.child_g = ctx.g;
+            push_ctx(p_ctx);
+          }
+          // case (START_ARRAY, Subscript :: Wildcard :: xs)
+          // case path 7
+          else if (7 == ctx.case_path) {
+            // collect result from child task
+            p_ctx.dirty += ctx.dirty;
+            // copy generator states to parent task;
+            p_ctx.g = ctx.g;
+            push_ctx(p_ctx);
+          }
+          /* case (START_ARRAY, Subscript :: Index(idx) :: (xs@Subscript :: Wildcard :: _)) */
+          // case path 8
+          // case (START_ARRAY, Subscript :: Index(idx) :: xs)
+          // case path 9
+          else if (8 == ctx.case_path || 9 == ctx.case_path) {
+            // collect result from child task
+            p_ctx.dirty += ctx.dirty;
+
+            // post logic:
+            while (p.next_token() != json_token::END_ARRAY) {
+              // JSON validation check
+              if (json_token::ERROR == p.get_current_token()) { return false; }
+              // advance the token stream to the end of the array
+              if (!p.try_skip_children()) { return false; }
+            }
+            // task is done
+            p_ctx.task_is_done = true;
+            // copy generator states to parent task;
+            p_ctx.g = ctx.g;
+            push_ctx(p_ctx);
+          }
+          // case (FIELD_NAME, Named(name) :: xs) if p.getCurrentName == name
+          // case path 10
+          else if (10 == ctx.case_path) {
+            // collect result from child task
+            p_ctx.dirty += ctx.dirty;
+            // task is done
+            p_ctx.task_is_done = true;
+            // copy generator states to parent task;
+            p_ctx.g = ctx.g;
+            push_ctx(p_ctx);
+          }
+          // case (FIELD_NAME, Wildcard :: xs)
+          // case path 11
+          else if (11 == ctx.case_path) {
+            // collect result from child task
+            p_ctx.dirty += ctx.dirty;
+            // task is done
+            p_ctx.task_is_done = true;
+            // copy generator states to parent task;
+            p_ctx.g = ctx.g;
+            push_ctx(p_ctx);
+          }
+          // case _ =>
+          // case path 12
+          else {
+            // never happen
+          }
+        } else {
+          // has no parent task, stack is empty, will exit
+        }
+      }
+    }
+
+    // copy output len
+    root_g.set_output_len(ctx.g.get_output_len());
+    return ctx.dirty > 0;
+  }
+};
+
+}  // namespace detail
+
+/**
+ * Extracts json object from a json string based on json path specified, and
+ * returns json string of the extracted json object. It will return null if the
+ * input json string is invalid.
+ */
+std::unique_ptr<cudf::column> get_json_object(
+  cudf::strings_column_view const& input,
+  std::vector<std::tuple<path_instruction_type, std::string, int64_t>> const& instructions,
+  rmm::cuda_stream_view stream        = cudf::get_default_stream(),
+  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+
+}  // namespace spark_rapids_jni
diff --git a/src/main/cpp/src/json_parser.hpp b/src/main/cpp/src/json_parser.hpp
new file mode 100644
index 0000000000..65c735d1ff
--- /dev/null
+++ b/src/main/cpp/src/json_parser.hpp
@@ -0,0 +1,1833 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "ftos_converter.cuh"
+
+#include <cudf/strings/detail/convert/string_to_float.cuh>
+#include <cudf/strings/string_view.hpp>
+#include <cudf/types.hpp>
+
+#include <thrust/pair.h>
+#include <thrust/tuple.h>
+
+namespace spark_rapids_jni {
+
+/**
+ * write style when writing out JSON string
+ */
+enum class write_style {
+  // e.g.: '\\r' is a string with 2 chars '\' 'r', writes 1 char '\r'
+  unescaped,
+
+  // * e.g.: '"' is a string with 1 char '"', writes out 4 chars '"' '\' '\"'
+  // '"'
+  escaped
+};
+
+// allow single quotes to represent strings in JSON
+// e.g.: {'k': 'v'} is valid when it's true
+constexpr bool curr_allow_single_quotes = true;
+
+// Whether allow unescaped control characters in JSON Strings.
+// Unescaped control characters are ASCII characters with value less than 32,
+// including tab and line feed characters. ASCII values range is [0, 32)
+// e.g.: ["\n"] is valid, here \n is one char
+// If true, JSON is not conventional format.
+// e.g., how to represent carriage return and newline characters:
+//   if true, allow "\n\r" two control characters without escape directly
+//   if false, "\n\r" are not allowed, should use escape characters: "\\n\\r"
+constexpr bool curr_allow_unescaped_control_chars = true;
+
+// deep JSON nesting depth will consume more memory, we can tuning this in
+// future. we ever run into a limit of 254, here use a small value 64.
+constexpr int curr_max_json_nesting_depth = 64;
+
+// Define the maximum JSON String length, counts utf8 bytes.
+// By default, maximum JSON String length is negative one, means no
+// limitation. e.g.: The length of String "\\n" is 1, JSON parser does not
+// count escape characters.
+constexpr int curr_max_string_utf8_bytes = 20000000;
+
+//
+/**
+ * Define the maximum JSON number length. Negative or zero means no
+ * limitation.
+ *
+ * By default, maximum JSON number length is negative one, means no
+ * limitation.
+ *
+ * e.g.: The length of number -123.45e-67 is 7. if maximum JSON number length
+ * is 6, then this number is a invalid number.
+ */
+constexpr int curr_max_num_len = 1000;
+
+/**
+ * whether allow tailing useless sub-string in JSON.
+ *
+ * If true, e.g., the following invalid JSON is allowed, because prefix {'k' :
+ * 'v'} is valid.
+ *   {'k' : 'v'}_extra_tail_sub_string
+ */
+constexpr bool curr_allow_tailing_sub_string = true;
+
+/**
+ * JSON token enum
+ */
+enum class json_token {
+  // start token
+  INIT = 0,
+
+  // successfully parsed the whole JSON string
+  SUCCESS,
+
+  // get error when parsing JSON string
+  ERROR,
+
+  // '{'
+  START_OBJECT,
+
+  // '}'
+  END_OBJECT,
+
+  // '['
+  START_ARRAY,
+
+  // ']'
+  END_ARRAY,
+
+  // e.g.: key1 in {"key1" : "value1"}
+  FIELD_NAME,
+
+  // e.g.: value1 in {"key1" : "value1"}
+  VALUE_STRING,
+
+  // e.g.: 123 in {"key1" : 123}
+  VALUE_NUMBER_INT,
+
+  // e.g.: 1.25 in {"key1" : 1.25}
+  VALUE_NUMBER_FLOAT,
+
+  // e.g.: true in {"key1" : true}
+  VALUE_TRUE,
+
+  // e.g.: false in {"key1" : false}
+  VALUE_FALSE,
+
+  // e.g.: null in {"key1" : null}
+  VALUE_NULL
+
+};
+
+/**
+ * JSON parser, provides token by token parsing.
+ * Follow Jackson JSON format by default.
+ *
+ *
+ * For JSON format:
+ * Refer to https://www.json.org/json-en.html.
+ *
+ * Note: when setting `allow_single_quotes` or `allow_unescaped_control_chars`,
+ * then JSON format is not conventional.
+ *
+ * White space can only be 4 chars: ' ', '\n', '\r', '\t',
+ * Jackson does not allow other control chars as white spaces.
+ *
+ * Valid number examples:
+ *   0, 102, -0, -102, 0.3, -0.3
+ *   1e-5, 1E+5, 1e0, 1E0, 1.3e5
+ *   1e01 : allow leading zeor after 'e'
+ *
+ * Invalid number examples:
+ *   00, -00   Leading zeroes not allowed
+ *   infinity, +infinity, -infinity
+ *   1e, 1e+, 1e-, -1., 1.
+ *
+ * When `allow_single_quotes` is true:
+ *   Valid string examples:
+ *     "\'" , "\"" ,  '\'' , '\"' , '"' , "'"
+ *
+ *  When `allow_single_quotes` is false:
+ *   Invalid string examples:
+ *     "\'"
+ *
+ *  When `allow_unescaped_control_chars` is true:
+ *    Valid string: "asscii_control_chars"
+ *      here `asscii_control_chars` represents control chars which in Ascii code
+ * range: [0, 32)
+ *
+ *  When `allow_unescaped_control_chars` is false:
+ *    Invalid string: "asscii_control_chars"
+ *      here `asscii_control_chars` represents control chars which in Ascii code
+ * range: [0, 32)
+ *
+ */
+template <bool allow_single_quotes           = curr_allow_single_quotes,
+          bool allow_unescaped_control_chars = curr_allow_unescaped_control_chars,
+          int max_json_nesting_depth         = curr_max_json_nesting_depth,
+          int max_string_utf8_bytes          = curr_max_string_utf8_bytes,
+          int max_num_len                    = curr_max_num_len,
+          bool allow_tailing_sub_string      = curr_allow_tailing_sub_string>
+class json_parser {
+ public:
+  __device__ inline json_parser(char const* const _json_start_pos, cudf::size_type const _json_len)
+    : json_start_pos(_json_start_pos),
+      json_end_pos(_json_start_pos + _json_len),
+      curr_pos(_json_start_pos)
+  {
+  }
+
+ private:
+  /**
+   * is current position EOF
+   */
+  __device__ inline bool eof(char const* pos) { return pos >= json_end_pos; }
+
+  /**
+   * is hex digits: 0-9, A-F, a-f
+   */
+  __device__ inline bool is_hex_digit(char c)
+  {
+    return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
+  }
+
+  /**
+   * is 0 to 9 digit
+   */
+  __device__ inline bool is_digit(char c) { return (c >= '0' && c <= '9'); }
+
+  /**
+   * is white spaces: ' ', '\t', '\n' '\r'
+   */
+  __device__ inline bool is_whitespace(char c)
+  {
+    return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+  }
+
+  /**
+   * skips 4 characters: ' ', '\t', '\n' '\r'
+   */
+  __device__ inline void skip_whitespaces(char const*& pos)
+  {
+    while (!eof(pos) && is_whitespace(*pos)) {
+      pos++;
+    }
+  }
+
+  /**
+   * check current char, if it's expected, then plus the position
+   */
+  __device__ inline bool try_skip(char const*& pos, char expected)
+  {
+    if (!eof(pos) && *pos == expected) {
+      pos++;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * try to push current context into stack
+   * if nested depth exceeds limitation, return false
+   */
+  __device__ inline bool try_push_context(json_token token)
+  {
+    if (stack_size < max_json_nesting_depth) {
+      push_context(token);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * record the nested state into stack: JSON object or JSON array
+   */
+  __device__ inline void push_context(json_token token)
+  {
+    bool v                      = json_token::START_OBJECT == token ? true : false;
+    context_stack[stack_size++] = v;
+  }
+
+  /**
+   * whether the top of nested context stack is JSON object context
+   * true is object, false is array
+   * only has two contexts: object or array
+   */
+  __device__ inline bool is_object_context() { return context_stack[stack_size - 1]; }
+
+  /**
+   * pop top context from stack
+   */
+  __device__ inline void pop_curr_context() { stack_size--; }
+
+  /**
+   * is context stack is empty
+   */
+  __device__ inline bool is_context_stack_empty() { return stack_size == 0; }
+
+  /**
+   * parse the first value token from current position
+   * e.g., after finished this function:
+   *   current token is START_OBJECT if current value is object
+   *   current token is START_ARRAY if current value is array
+   *   current token is string/num/true/false/null if current value is terminal
+   *   current token is ERROR if parse failed
+   */
+  __device__ inline void parse_first_token_in_value()
+  {
+    // already checked eof
+    char c = *curr_pos;
+    switch (c) {
+      case '{':
+        if (!try_push_context(json_token::START_OBJECT)) {
+          curr_token = json_token::ERROR;
+          return;
+        }
+        curr_pos++;
+        curr_token = json_token::START_OBJECT;
+        break;
+
+      case '[':
+        if (!try_push_context(json_token::START_ARRAY)) {
+          curr_token = json_token::ERROR;
+          return;
+        }
+        curr_pos++;
+        curr_token = json_token::START_ARRAY;
+        break;
+
+      case '"': parse_double_quoted_string(); break;
+
+      case '\'':
+        if (allow_single_quotes) {
+          parse_single_quoted_string();
+        } else {
+          curr_token = json_token::ERROR;
+        }
+        break;
+
+      case 't':
+        curr_pos++;
+        parse_true();
+        break;
+
+      case 'f':
+        curr_pos++;
+        parse_false();
+        break;
+
+      case 'n':
+        curr_pos++;
+        parse_null();
+        break;
+
+      default: parse_number();
+    }
+  }
+
+  // =========== Parse string begin ===========
+
+  /**
+   * parse ' quoted string
+   */
+  __device__ inline void parse_single_quoted_string()
+  {
+    auto [success, end_char_pos] =
+      try_parse_single_quoted_string(curr_pos, nullptr, nullptr, nullptr, write_style::unescaped);
+    if (success) {
+      curr_pos   = end_char_pos;
+      curr_token = json_token::VALUE_STRING;
+    } else {
+      curr_token = json_token::ERROR;
+    }
+  }
+
+  /**
+   * parse " quoted string
+   */
+  __device__ inline void parse_double_quoted_string()
+  {
+    auto [success, end_char_pos] =
+      try_parse_double_quoted_string(curr_pos, nullptr, nullptr, nullptr, write_style::unescaped);
+    if (success) {
+      curr_pos   = end_char_pos;
+      curr_token = json_token::VALUE_STRING;
+    } else {
+      curr_token = json_token::ERROR;
+    }
+  }
+
+  /*
+   * try parse ' or " quoted string
+   *
+   * when allow single quote, first try single quote
+   * @param str_pos str start position for parsing, should be a position in JSON
+   * string
+   * @param to_match_str_pos expected match str position, nullptr means do not
+   * match
+   * @param to_match_str_end expected match str end
+   * @param copy_destination copy unescaped str to destination, nullptr means do
+   * not copy
+   * @return whether passed successfully and the end position of parsed str
+   *
+   */
+  __device__ inline std::pair<bool, char const*> try_parse_string(
+    char const* str_pos,
+    char const* to_match_str_pos,
+    char const* const to_match_str_end,
+    char* copy_destination,
+    write_style w_style)
+  {
+    if (!eof(str_pos)) {
+      if (allow_single_quotes && *str_pos == '\'') {
+        return try_parse_single_quoted_string(
+          str_pos, to_match_str_pos, to_match_str_end, copy_destination, w_style);
+      } else {
+        return try_parse_double_quoted_string(
+          str_pos, to_match_str_pos, to_match_str_end, copy_destination, w_style);
+      }
+    } else {
+      return std::make_pair(false, nullptr);
+    }
+  }
+
+  /**
+   * try parse ' quoted string
+   *
+   * when allow single quote, first try single quote
+   * @param str_pos str start position for parsing, should be a position in JSON
+   * string
+   * @param to_match_str_pos expected match str position, nullptr means do not
+   * match
+   * @param to_match_str_end expected match str end
+   * @param copy_destination copy unescaped str to destination, nullptr means do
+   * not copy
+   *
+   */
+  __device__ inline std::pair<bool, char const*> try_parse_single_quoted_string(
+    char const* str_pos,
+    char const* to_match_str_pos,
+    char const* const to_match_str_end,
+    char* copy_destination,
+    write_style w_style)
+  {
+    return try_parse_quoted_string(str_pos,
+                                   '\'',
+                                   to_match_str_pos,  // match str pos, nullptr means do not match
+                                   to_match_str_end,  // match str end
+                                   copy_destination,  // copy destination while parsing, nullptr
+                                                      // means do not copy
+                                   w_style);
+  }
+
+  /**
+   * try parse " quoted string.
+   *
+   * when allow single quote, first try single quote
+   * @param str_pos str start position for parsing, should be a position in JSON
+   * string
+   * @param to_match_str_pos expected match str position, nullptr means do not
+   * match
+   * @param to_match_str_end expected match str end
+   * @param copy_destination copy unescaped str to destination, nullptr means do
+   * not copy
+   *
+   */
+  __device__ inline std::pair<bool, char const*> try_parse_double_quoted_string(
+    char const* str_pos,
+    char const* to_match_str_pos,
+    char const* const to_match_str_end,
+    char* copy_destination,
+    write_style w_style)
+  {
+    return try_parse_quoted_string(str_pos,
+                                   '\"',
+                                   to_match_str_pos,  // match str pos, nullptr means do not match
+                                   to_match_str_end,  // match str end
+                                   copy_destination,  // copy destination while parsing, nullptr
+                                                      // means do not copy
+                                   w_style);
+  }
+
+  /**
+   * transform int value from [0, 15] to hex char
+   */
+  __device__ inline char to_hex_char(unsigned int v)
+  {
+    if (v < 10)
+      return '0' + v;
+    else
+      return 'A' + (v - 10);
+  }
+
+  /**
+   * escape control char ( ASCII code value [0, 32) )
+   * e.g.: \0  (ASCII code 0) will be escaped to 6 chars: \u0000
+   * e.g.: \10 (ASCII code 0) will be escaped to 2 chars: \n
+   * @param char to be escaped, c should in range [0, 31)
+   * @param[out] escape output
+   */
+  __device__ inline int escape_char(unsigned char c, char* output)
+  {
+    if (nullptr == output) {
+      switch (c) {
+        case 8:             // \b
+        case 9:             // \t
+        case 10:            // \n
+        case 12:            // \f
+        case 13: return 2;  // \r
+        default: return 6;  // \u0000
+      }
+    }
+    switch (c) {
+      case 8:
+        output[0] = '\\';
+        output[1] = 'b';
+        return 2;
+      case 9:
+        output[0] = '\\';
+        output[1] = 't';
+        return 2;
+      case 10:
+        output[0] = '\\';
+        output[1] = 'n';
+        return 2;
+      case 12:
+        output[0] = '\\';
+        output[1] = 'f';
+        return 2;
+      case 13:
+        output[0] = '\\';
+        output[1] = 'r';
+        return 2;
+      default:
+        output[0] = '\\';
+        output[1] = 'u';
+        output[2] = '0';
+        output[3] = '0';
+
+        // write high digit
+        if (c >= 16) {
+          output[4] = '1';
+        } else {
+          output[4] = '0';
+        }
+
+        // write low digit
+        unsigned int v = c % 16;
+        output[5]      = to_hex_char(v);
+        return 6;
+    }
+  }
+
+  /**
+   * utility for parsing string, this function does not update the parser
+   * internal try parse quoted string using passed `quote_char` `quote_char` can
+   * be ' or " For UTF-8 encoding: Single byte char: The most significant bit of
+   * the byte is always 0 Two-byte characters: The leading bits of the first
+   * byte are 110, and the leading bits of the second byte are 10. Three-byte
+   * characters: The leading bits of the first byte are 1110, and the leading
+   * bits of the second and third bytes are 10. Four-byte characters: The
+   * leading bits of the first byte are 11110, and the leading bits of the
+   * second, third, and fourth bytes are 10. Because JSON structural chars([ ] {
+   * } , :), string quote char(" ') and Escape char \ are all Ascii(The leading
+   * bit is 0), so it's safe that do not convert byte array to UTF-8 char.
+   *
+   * When quote is " and allow_unescaped_control_chars is false, grammar is:
+   *
+   *   STRING
+   *     : '"' (ESC | SAFECODEPOINT)* '"'
+   *     ;
+   *
+   *   fragment ESC
+   *     : '\\' (["\\/bfnrt] | UNICODE)
+   *     ;
+   *
+   *   fragment UNICODE
+   *     : 'u' HEX HEX HEX HEX
+   *     ;
+   *
+   *   fragment HEX
+   *     : [0-9a-fA-F]
+   *     ;
+   *
+   *   fragment SAFECODEPOINT
+   *       // 1 not " or ' depending to allow_single_quotes
+   *       // 2 not \
+   *       // 3 non control character: Ascii value not in [0, 32)
+   *     : ~ ["\\\u0000-\u001F]
+   *     ;
+   *
+   * When allow_unescaped_control_chars is true:
+   *   Allow [0-32) control Ascii chars directly without escape
+   * When allow_single_quotes is true:
+   *   These strings are allowed: '\'' , '\"' , '"' , "\"" , "\'" , "'"
+   * @param str_pos str start position for parsing, should be a position in JSON
+   * string
+   * @param quote_char expected quote char
+   * @param to_match_str_pos expected match str position, nullptr means do not
+   * match
+   * @param to_match_str_end expected match str end
+   * @param copy_destination copy unescaped str to destination, nullptr means do
+   * not copy
+   */
+  __device__ inline std::pair<bool, char const*> try_parse_quoted_string(
+    char const* str_pos,
+    char const quote_char,
+    char const* to_match_str_pos,
+    char const* const to_match_str_end,
+    char* copy_destination,
+    write_style w_style)
+  {
+    // update state
+    string_token_utf8_bytes       = 0;
+    bytes_diff_for_escape_writing = 0;
+
+    // write the first " if write style is escaped
+    if (write_style::escaped == w_style) {
+      bytes_diff_for_escape_writing++;
+      if (nullptr != copy_destination) { *copy_destination++ = '"'; }
+    }
+
+    // skip left quote char
+    if (!try_skip(str_pos, quote_char)) { return std::make_pair(false, nullptr); }
+
+    // scan string content
+    while (!eof(str_pos)) {
+      char c = *str_pos;
+      int v  = static_cast<int>(c);
+      if (c == quote_char) {
+        // path 1: match closing quote char
+        str_pos++;
+
+        // check max str len
+        if (!check_string_max_utf8_bytes()) { return std::make_pair(false, nullptr); }
+
+        // match check, the last char in match_str is quote_char
+        if (nullptr != to_match_str_pos) {
+          // match check, the last char in match_str is quote_char
+          if (to_match_str_pos != to_match_str_end) { return std::make_pair(false, nullptr); }
+        }
+
+        // write the end " if write style is escaped
+        if (write_style::escaped == w_style) {
+          bytes_diff_for_escape_writing++;
+          if (nullptr != copy_destination) { *copy_destination++ = '"'; }
+        }
+
+        return std::make_pair(true, str_pos);
+      } else if (v >= 0 && v < 32 && allow_unescaped_control_chars) {
+        // path 2: unescaped control char
+
+        // copy if enabled, unescape mode, write 1 char
+        if (copy_destination != nullptr && write_style::unescaped == w_style) {
+          *copy_destination++ = *str_pos;
+        }
+
+        // copy if enabled, escape mode, write more chars
+        if (write_style::escaped == w_style) {
+          int escape_chars = escape_char(*str_pos, copy_destination);
+          if (copy_destination != nullptr) copy_destination += escape_chars;
+          bytes_diff_for_escape_writing += (escape_chars - 1);
+        }
+
+        // check match if enabled
+        if (!try_match_char(to_match_str_pos, to_match_str_end, *str_pos)) {
+          return std::make_pair(false, nullptr);
+        }
+
+        str_pos++;
+        string_token_utf8_bytes++;
+        continue;
+      } else if ('\\' == c) {
+        // path 3: escape path
+        str_pos++;
+        if (!try_skip_escape_part(
+              str_pos, to_match_str_pos, to_match_str_end, copy_destination, w_style)) {
+          return std::make_pair(false, nullptr);
+        }
+      } else {
+        // path 4: safe code point
+
+        // handle single unescaped " char; happens when string is quoted by char '
+        // e.g.:  'A"' string, escape to "A\\"" (5 chars: " A \ " ")
+        if ('\"' == c && write_style::escaped == w_style) {
+          if (copy_destination != nullptr) { *copy_destination++ = '\\'; }
+          bytes_diff_for_escape_writing++;
+        }
+
+        if (!try_skip_safe_code_point(str_pos, c)) { return std::make_pair(false, nullptr); }
+        if (copy_destination != nullptr) { *copy_destination++ = c; }
+        // check match if enabled
+        if (!try_match_char(to_match_str_pos, to_match_str_end, c)) {
+          return std::make_pair(false, nullptr);
+        }
+        string_token_utf8_bytes++;
+      }
+    }
+
+    return std::make_pair(false, nullptr);
+  }
+
+  __device__ inline bool try_match_char(char const*& char_pos,
+                                        char const* const char_end_pos,
+                                        char c)
+  {
+    if (nullptr != char_pos) {
+      if (char_pos < char_end_pos && *char_pos == c) {
+        char_pos++;
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      return true;
+    }
+  }
+
+  /**
+   * skip the second char in \", \', \\, \/, \b, \f, \n, \r, \t;
+   * skip the HEX chars in \u HEX HEX HEX HEX.
+   * @return positive escaped ASCII value if success, -1 otherwise
+   */
+  __device__ inline bool try_skip_escape_part(char const*& str_pos,
+                                              char const*& to_match_str_pos,
+                                              char const* const to_match_str_end,
+                                              char*& copy_dest,
+                                              write_style w_style)
+  {
+    // already skipped the first '\'
+    // try skip second part
+    if (!eof(str_pos)) {
+      char c = *str_pos;
+      switch (*str_pos) {
+        // path 1: \", \', \\, \/, \b, \f, \n, \r, \t
+        case '\"':
+          if (nullptr != copy_dest && write_style::unescaped == w_style) { *copy_dest++ = c; }
+          if (write_style::escaped == w_style) {
+            if (copy_dest != nullptr) {
+              *copy_dest++ = '\\';
+              *copy_dest++ = '"';
+            }
+            bytes_diff_for_escape_writing++;
+          }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, c)) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        case '\'':
+          // only allow escape ' when `allow_single_quotes`
+          if (allow_single_quotes) {
+            // for both unescaped/escaped writes a single char '
+            if (nullptr != copy_dest) { *copy_dest++ = c; }
+            if (!try_match_char(to_match_str_pos, to_match_str_end, c)) { return false; }
+
+            string_token_utf8_bytes++;
+            str_pos++;
+            return true;
+          } else {
+            return false;
+          }
+        case '\\':
+          if (nullptr != copy_dest && write_style::unescaped == w_style) { *copy_dest++ = c; }
+          if (write_style::escaped == w_style) {
+            if (copy_dest != nullptr) {
+              *copy_dest++ = '\\';
+              *copy_dest++ = '\\';
+            }
+            bytes_diff_for_escape_writing++;
+          }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, c)) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        case '/':
+          // for both unescaped/escaped writes a single char /
+          if (nullptr != copy_dest) { *copy_dest++ = c; }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, c)) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        case 'b':
+          if (nullptr != copy_dest && write_style::unescaped == w_style) { *copy_dest++ = '\b'; }
+          if (write_style::escaped == w_style) {
+            if (copy_dest != nullptr) {
+              *copy_dest++ = '\\';
+              *copy_dest++ = 'b';
+            }
+            bytes_diff_for_escape_writing++;
+          }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, '\b')) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        case 'f':
+          if (nullptr != copy_dest && write_style::unescaped == w_style) { *copy_dest++ = '\f'; }
+          if (write_style::escaped == w_style) {
+            if (copy_dest != nullptr) {
+              *copy_dest++ = '\\';
+              *copy_dest++ = 'f';
+            }
+            bytes_diff_for_escape_writing++;
+          }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, '\f')) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        case 'n':
+          if (nullptr != copy_dest && write_style::unescaped == w_style) { *copy_dest++ = '\n'; }
+          if (write_style::escaped == w_style) {
+            if (copy_dest != nullptr) {
+              *copy_dest++ = '\\';
+              *copy_dest++ = 'n';
+            }
+            bytes_diff_for_escape_writing++;
+          }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, '\n')) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        case 'r':
+          if (nullptr != copy_dest && write_style::unescaped == w_style) { *copy_dest++ = '\r'; }
+          if (write_style::escaped == w_style) {
+            if (copy_dest != nullptr) {
+              *copy_dest++ = '\\';
+              *copy_dest++ = 'r';
+            }
+            bytes_diff_for_escape_writing++;
+          }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, '\r')) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        case 't':
+          if (nullptr != copy_dest && write_style::unescaped == w_style) { *copy_dest++ = '\t'; }
+          if (write_style::escaped == w_style) {
+            if (copy_dest != nullptr) {
+              *copy_dest++ = '\\';
+              *copy_dest++ = 't';
+            }
+            bytes_diff_for_escape_writing++;
+          }
+          if (!try_match_char(to_match_str_pos, to_match_str_end, '\t')) { return false; }
+          string_token_utf8_bytes++;
+          str_pos++;
+          return true;
+        // path 1 done: \", \', \\, \/, \b, \f, \n, \r, \t
+        case 'u':
+          // path 2: \u HEX HEX HEX HEX
+          str_pos++;
+
+          // for both unescaped/escaped writes corresponding utf8 bytes, no need
+          // to pass in write style
+          return try_skip_unicode(str_pos, to_match_str_pos, to_match_str_end, copy_dest);
+        default:
+          // path 3: invalid
+          return false;
+      }
+    } else {
+      // eof, no escaped char after char '\'
+      return false;
+    }
+  }
+
+  /**
+   * parse:
+   *   fragment SAFECODEPOINT
+   *       // 1 not " or ' depending to allow_single_quotes
+   *       // 2 not \
+   *       // 3 non control character: Ascii value not in [0, 32)
+   *     : ~ ["\\\u0000-\u001F]
+   *     ;
+   */
+  __device__ inline bool try_skip_safe_code_point(char const*& str_pos, char c)
+  {
+    // 1 the char is not quoted(' or ") char, here satisfy, do not need to check
+    // again
+
+    // 2. the char is not \, here satisfy, do not need to check again
+
+    // 3. chars not in [0, 32)
+    int v = static_cast<int>(c);
+    if (!(v >= 0 && v < 32)) {
+      str_pos++;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * convert chars 0-9, a-f, A-F to int value
+   */
+  __device__ inline uint8_t hex_value(char c)
+  {
+    if (c >= '0' && c <= '9') return c - '0';
+    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+    return 0;
+  }
+
+  /**
+   * parse four HEX chars to unsigned int
+   */
+  __device__ inline cudf::char_utf8 parse_code_point(char const* p)
+  {
+    cudf::char_utf8 v = 0;
+    for (size_t i = 0; i < 4; i++) {
+      v = v * 16 + hex_value(p[i]);
+    }
+    return v;
+  }
+
+  /**
+   * @brief Returns the number of bytes in the specified character.
+   *
+   * @param character Single character
+   * @return Number of bytes
+   */
+  __device__ cudf::size_type bytes_in_char_utf8(cudf::char_utf8 character)
+  {
+    return 1 + static_cast<cudf::size_type>((character & 0x0000'FF00u) > 0) +
+           static_cast<cudf::size_type>((character & 0x00FF'0000u) > 0) +
+           static_cast<cudf::size_type>((character & 0xFF00'0000u) > 0);
+  }
+
+  /**
+   * @brief Converts a character code-point value into a UTF-8 character.
+   *
+   * @param unchr Character code-point to convert.
+   * @return Single UTF-8 character.
+   */
+  __device__ cudf::char_utf8 codepoint_to_utf8(uint32_t unchr)
+  {
+    cudf::char_utf8 utf8 = 0;
+    if (unchr < 0x0000'0080) {
+      // single byte utf8
+      utf8 = unchr;
+    } else if (unchr < 0x0000'0800) {
+      // double byte utf8
+      utf8 = (unchr << 2) & 0x1F00;
+      utf8 |= (unchr & 0x3F);
+      utf8 |= 0x0000'C080;
+    } else if (unchr < 0x0001'0000) {
+      // triple byte utf8
+      utf8 = (unchr << 4) & 0x0F'0000;
+      utf8 |= (unchr << 2) & 0x00'3F00;
+      utf8 |= (unchr & 0x3F);
+      utf8 |= 0x00E0'8080;
+    } else if (unchr < 0x0011'0000) {
+      // quadruple byte utf8
+      utf8 = (unchr << 6) & 0x0700'0000;
+      utf8 |= (unchr << 4) & 0x003F'0000;
+      utf8 |= (unchr << 2) & 0x0000'3F00;
+      utf8 |= (unchr & 0x3F);
+      utf8 |= 0xF080'8080u;
+    }
+    return utf8;
+  }
+
+  /**
+   * @brief Place a char_utf8 value into a char array.
+   *
+   * @param character Single character
+   * @param[out] str Output array.
+   * @return The number of bytes in the character
+   */
+  __device__ cudf::size_type from_char_utf8(cudf::char_utf8 character, char* str)
+  {
+    cudf::size_type const chr_width = bytes_in_char_utf8(character);
+    for (cudf::size_type idx = 0; idx < chr_width; ++idx) {
+      str[chr_width - idx - 1] = static_cast<char>(character) & 0xFF;
+      character                = character >> 8;
+    }
+    return chr_width;
+  }
+
+  /**
+   * try skip 4 HEX chars
+   * in pattern: '\\' 'u' HEX HEX HEX HEX, it's a code point of unicode
+   */
+  __device__ bool try_skip_unicode(char const*& str_pos,
+                                   char const*& to_match_str_pos,
+                                   char const* const to_match_str_end,
+                                   char*& copy_dest)
+  {
+    // already parsed u
+    bool is_success = try_skip_hex(str_pos) && try_skip_hex(str_pos) && try_skip_hex(str_pos) &&
+                      try_skip_hex(str_pos);
+    if (is_success) {
+      // parse 4 HEX chars to uint32_t value
+      auto code_point = parse_code_point(str_pos - 4);
+      auto utf_char   = codepoint_to_utf8(code_point);
+      // write utf8 bytes.
+      // In UTF-8, the maximum number of bytes used to encode a single character
+      // is 4
+      char buff[4];
+      cudf::size_type bytes = from_char_utf8(utf_char, buff);
+      string_token_utf8_bytes += bytes;
+
+      if (nullptr != copy_dest) {
+        for (cudf::size_type i = 0; i < bytes; i++) {
+          *copy_dest++ = buff[i];
+        }
+      }
+
+      if (nullptr != to_match_str_pos) {
+        for (cudf::size_type i = 0; i < bytes; i++) {
+          if (!(to_match_str_pos < to_match_str_end && *to_match_str_pos == buff[i])) {
+            return false;
+          }
+          to_match_str_pos++;
+        }
+      }
+
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * try skip HEX
+   */
+  __device__ inline bool try_skip_hex(char const*& str_pos)
+  {
+    if (!eof(str_pos) && is_hex_digit(*str_pos)) {
+      str_pos++;
+      return true;
+    }
+    return false;
+  }
+
+  // =========== Parse string end ===========
+
+  // =========== Parse number begin ===========
+
+  /**
+   * parse number, grammar is:
+   * NUMBER
+   *   : '-'? INT ('.' [0-9]+)? EXP?
+   *   ;
+   *
+   * fragment INT
+   *   // integer part forbis leading 0s (e.g. `01`)
+   *   : '0'
+   *   | [1-9] [0-9]*
+   *   ;
+   *
+   * fragment EXP
+   *   : [Ee] [+\-]? [0-9]+
+   *   ;
+   *
+   * valid number:    0, 0.3, 0e005, 0E005
+   * invalid number:  0., 0e, 0E
+   *
+   * Note: Leading zeroes are not allowed, keep consistent with Spark, e.g.: 00, -01 are invalid
+   */
+  __device__ inline void parse_number()
+  {
+    // reset the float parts
+    float_integer_len  = 0;
+    float_fraction_len = 0;
+    float_exp_len      = 0;
+    float_exp_has_sign = false;
+
+    // parse sign
+    if (try_skip(curr_pos, '-')) {
+      float_sign = false;
+    } else {
+      float_sign = true;
+    }
+    float_integer_pos = curr_pos;
+
+    // parse unsigned number
+    bool is_float = false;
+    if (try_unsigned_number(is_float)) {
+      if (check_max_num_len()) {
+        curr_token = (is_float ? json_token::VALUE_NUMBER_FLOAT : json_token::VALUE_NUMBER_INT);
+        // success parsed a number, update the token length
+        number_token_len = curr_pos - current_token_start_pos;
+      } else {
+        curr_token = json_token::ERROR;
+      }
+    } else {
+      curr_token = json_token::ERROR;
+    }
+  }
+
+  /**
+   * verify max number length if enabled
+   * e.g.: -1.23e-456, int len is 1, fraction len is 2, exp digits len is 3
+   */
+  __device__ inline bool check_max_num_len()
+  {
+    // exp part contains + or - sign char, do not count the exp sign
+    int exp_digit_len = float_exp_len;
+    if (float_exp_len > 0 && float_exp_has_sign) { exp_digit_len--; }
+
+    int sum_len = float_integer_len + float_fraction_len + exp_digit_len;
+    return
+      // disabled num len check
+      max_num_len <= 0 ||
+      // enabled num len check
+      (max_num_len > 0 && sum_len <= max_num_len);
+  }
+
+  /**
+   * verify max string length if enabled
+   */
+  __device__ inline bool check_string_max_utf8_bytes()
+  {
+    return
+      // disabled str len check
+      max_string_utf8_bytes <= 0 ||
+      // enabled str len check
+      (max_string_utf8_bytes > 0 && string_token_utf8_bytes <= max_string_utf8_bytes);
+  }
+
+  /**
+   * parse:  INT ('.' [0-9]+)? EXP?
+   * and verify leading zeroes
+   *
+   * @param[out] is_float, if contains `.` or `e`, set true
+   */
+  __device__ inline bool try_unsigned_number(bool& is_float)
+  {
+    if (!eof(curr_pos)) {
+      char c = *curr_pos;
+      if (c >= '1' && c <= '9') {
+        curr_pos++;
+        float_integer_len++;
+        // first digit is [1-9]
+        // path: INT = [1-9] [0-9]*
+        float_integer_len += skip_zero_or_more_digits();
+        return parse_number_from_fraction(is_float);
+      } else if (c == '0') {
+        curr_pos++;
+        float_integer_len++;
+
+        // check leading zeros
+        if (!eof(curr_pos)) {
+          char next_char_after_zero = *curr_pos;
+          if (next_char_after_zero >= '0' && next_char_after_zero <= '9') {
+            // e.g.: 01 is invalid
+            return false;
+          }
+        }
+
+        // first digit is [0]
+        // path: INT = '0'
+        return parse_number_from_fraction(is_float);
+      } else {
+        // first digit is non [0-9]
+        return false;
+      }
+    } else {
+      // eof, has no digits
+      return false;
+    }
+  }
+
+  /**
+   * parse: ('.' [0-9]+)? EXP?
+   * @param[is_float] is float
+   */
+  __device__ inline bool parse_number_from_fraction(bool& is_float)
+  {
+    // parse fraction
+    if (try_skip(curr_pos, '.')) {
+      // has fraction
+      float_fraction_pos = curr_pos;
+      is_float           = true;
+      // try pattern: [0-9]+
+      if (!try_skip_one_or_more_digits(float_fraction_len)) { return false; }
+    }
+
+    // parse exp
+    if (!eof(curr_pos) && (*curr_pos == 'e' || *curr_pos == 'E')) {
+      curr_pos++;
+      is_float = true;
+      return try_parse_exp();
+    }
+
+    return true;
+  }
+
+  /**
+   * parse: [0-9]*
+   * skip zero or more [0-9]
+   */
+  __device__ inline int skip_zero_or_more_digits()
+  {
+    int digits = 0;
+    while (!eof(curr_pos)) {
+      if (is_digit(*curr_pos)) {
+        digits++;
+        curr_pos++;
+      } else {
+        // point to first non-digit char
+        break;
+      }
+    }
+    return digits;
+  }
+
+  /**
+   * parse: [0-9]+
+   * try skip one or more [0-9]
+   * @param[out] len: skipped num of digits
+   */
+  __device__ inline bool try_skip_one_or_more_digits(int& len)
+  {
+    if (!eof(curr_pos) && is_digit(*curr_pos)) {
+      curr_pos++;
+      len++;
+      len += skip_zero_or_more_digits();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * parse [eE][+-]?[0-9]+
+   * @param[out] exp_len exp len
+   */
+  __device__ inline bool try_parse_exp()
+  {
+    // already parsed [eE]
+
+    float_exp_pos = curr_pos;
+
+    // parse [+-]?
+    if (!eof(curr_pos) && (*curr_pos == '+' || *curr_pos == '-')) {
+      float_exp_len++;
+      curr_pos++;
+      float_exp_has_sign = true;
+    }
+
+    // parse [0-9]+
+    return try_skip_one_or_more_digits(float_exp_len);
+  }
+
+  // =========== Parse number end ===========
+
+  /**
+   * parse true
+   */
+  __device__ inline void parse_true()
+  {
+    // already parsed 't'
+    if (try_skip(curr_pos, 'r') && try_skip(curr_pos, 'u') && try_skip(curr_pos, 'e')) {
+      curr_token = json_token::VALUE_TRUE;
+    } else {
+      curr_token = json_token::ERROR;
+    }
+  }
+
+  /**
+   * parse false
+   */
+  __device__ inline void parse_false()
+  {
+    // already parsed 'f'
+    if (try_skip(curr_pos, 'a') && try_skip(curr_pos, 'l') && try_skip(curr_pos, 's') &&
+        try_skip(curr_pos, 'e')) {
+      curr_token = json_token::VALUE_FALSE;
+    } else {
+      curr_token = json_token::ERROR;
+    }
+  }
+
+  /**
+   * parse null
+   */
+  __device__ inline void parse_null()
+  {
+    // already parsed 'n'
+    if (try_skip(curr_pos, 'u') && try_skip(curr_pos, 'l') && try_skip(curr_pos, 'l')) {
+      curr_token = json_token::VALUE_NULL;
+    } else {
+      curr_token = json_token::ERROR;
+    }
+  }
+
+  /**
+   * parse the key string in key:value pair
+   */
+  __device__ inline void parse_field_name()
+  {
+    auto [success, end_char_pos] =
+      try_parse_string(curr_pos, nullptr, nullptr, nullptr, write_style::unescaped);
+    if (success) {
+      curr_pos   = end_char_pos;
+      curr_token = json_token::FIELD_NAME;
+    } else {
+      curr_token = json_token::ERROR;
+    }
+  }
+
+  /**
+   * continute parsing the next token and update current token
+   * Note: only parse one token at a time
+   * @param[out] has_comma_before_token has comma before next token
+   * @param[out] has_colon_before_token has colon before next token
+   */
+  __device__ inline json_token parse_next_token(bool& has_comma_before_token,
+                                                bool& has_colon_before_token)
+  {
+    skip_whitespaces(curr_pos);
+    if (!eof(curr_pos)) {
+      char c = *curr_pos;
+      if (is_context_stack_empty()) {
+        // stack is empty
+
+        if (curr_token == json_token::INIT) {
+          // main root entry point
+          current_token_start_pos = curr_pos;
+          parse_first_token_in_value();
+        } else {
+          if (allow_tailing_sub_string) {
+            // previous token is not INIT, means already get a token; stack is
+            // empty; Successfully parsed. Note: ignore the tailing sub-string
+            curr_token = json_token::SUCCESS;
+          } else {
+            // not eof, has extra useless tailing characters.
+            curr_token = json_token::ERROR;
+          }
+        }
+      } else {
+        // stack is non-empty
+
+        if (is_object_context()) {
+          // in JSON object context
+          if (curr_token == json_token::START_OBJECT) {
+            // previous token is '{'
+            if (c == '}') {
+              // empty object
+              // close curr object context
+              current_token_start_pos = curr_pos;
+              curr_pos++;
+              curr_token = json_token::END_OBJECT;
+              pop_curr_context();
+            } else {
+              // parse key in key:value pair
+              current_token_start_pos = curr_pos;
+              parse_field_name();
+            }
+          } else if (curr_token == json_token::FIELD_NAME) {
+            if (c == ':') {
+              has_colon_before_token = true;
+              // skip ':' and parse value in key:value pair
+              curr_pos++;
+              skip_whitespaces(curr_pos);
+              current_token_start_pos = curr_pos;
+              parse_first_token_in_value();
+            } else {
+              curr_token = json_token::ERROR;
+            }
+          } else {
+            // expect next key:value pair or '}'
+            if (c == '}') {
+              // end of object
+              current_token_start_pos = curr_pos;
+              curr_pos++;
+              curr_token = json_token::END_OBJECT;
+              pop_curr_context();
+            } else if (c == ',') {
+              has_comma_before_token = true;
+              // parse next key:value pair
+              curr_pos++;
+              skip_whitespaces(curr_pos);
+              current_token_start_pos = curr_pos;
+              parse_field_name();
+            } else {
+              curr_token = json_token::ERROR;
+            }
+          }
+        } else {
+          // in Json array context
+          if (curr_token == json_token::START_ARRAY) {
+            // previous token is '['
+            if (c == ']') {
+              // curr: ']', empty array
+              current_token_start_pos = curr_pos;
+              curr_pos++;
+              curr_token = json_token::END_ARRAY;
+              pop_curr_context();
+            } else {
+              // non-empty array, parse the first value in the array
+              current_token_start_pos = curr_pos;
+              parse_first_token_in_value();
+            }
+          } else {
+            if (c == ',') {
+              has_comma_before_token = true;
+              // skip ',' and parse the next value
+              curr_pos++;
+              skip_whitespaces(curr_pos);
+              current_token_start_pos = curr_pos;
+              parse_first_token_in_value();
+            } else if (c == ']') {
+              // end of array
+              current_token_start_pos = curr_pos;
+              curr_pos++;
+              curr_token = json_token::END_ARRAY;
+              pop_curr_context();
+            } else {
+              curr_token = json_token::ERROR;
+            }
+          }
+        }
+      }
+    } else {
+      // eof
+      if (is_context_stack_empty() && curr_token != json_token::INIT) {
+        // reach eof; stack is empty; previous token is not INIT
+        curr_token = json_token::SUCCESS;
+      } else {
+        // eof, and meet the following cases:
+        //   - has unclosed JSON array/object;
+        //   - the whole JSON is empty
+        curr_token = json_token::ERROR;
+      }
+    }
+    return curr_token;
+  }
+
+ public:
+  /**
+   * continute parsing, get next token.
+   * The final tokens are ERROR or SUCCESS;
+   */
+  __device__ json_token next_token()
+  {
+    // parse next token
+    bool has_comma_before_token;  // no-initialization because of do not care here
+    bool has_colon_before_token;  // no-initialization because of do not care here
+    return parse_next_token(has_comma_before_token, has_colon_before_token);
+  }
+
+  /**
+   * get current token
+   */
+  __device__ json_token get_current_token() { return curr_token; }
+
+  /**
+   * is valid JSON by parsing through all tokens
+   */
+  __device__ bool is_valid()
+  {
+    while (curr_token != json_token::ERROR && curr_token != json_token::SUCCESS) {
+      next_token();
+    }
+    return curr_token == json_token::SUCCESS;
+  }
+
+  /**
+   * skip children if current token is [ or {, or do nothing otherwise.
+   * after this call, the current token is ] or } if token is { or [
+   * @return true if JSON is valid so far, false otherwise.
+   */
+  __device__ bool try_skip_children()
+  {
+    if (curr_token == json_token::ERROR || curr_token == json_token::INIT ||
+        curr_token == json_token::SUCCESS) {
+      return false;
+    }
+
+    if (curr_token != json_token::START_OBJECT && curr_token != json_token::START_ARRAY) {
+      return true;
+    }
+
+    int open = 1;
+    while (true) {
+      json_token t = next_token();
+      if (t == json_token::START_OBJECT || t == json_token::START_ARRAY) {
+        ++open;
+      } else if (t == json_token::END_OBJECT || t == json_token::END_ARRAY) {
+        if (--open == 0) { return true; }
+      } else if (t == json_token::ERROR) {
+        return false;
+      }
+    }
+  }
+
+  __device__ cudf::size_type compute_unescaped_len() { return write_unescaped_text(nullptr); }
+
+  /**
+   * unescape current token text, then write to destination
+   * e.g.: '\\r' is a string with 2 chars '\' 'r', writes 1 char '\r'
+   * e.g.: "\u4e2d\u56FD" are code points for Chinese chars "中国",
+   *   writes 6 utf8 bytes: -28  -72 -83 -27 -101 -67
+   * For number, write verbatim without normalization
+   */
+  __device__ cudf::size_type write_unescaped_text(char* destination)
+  {
+    switch (curr_token) {
+      case json_token::VALUE_STRING:
+        // can not copy from JSON directly due to escaped chars
+        // rewind the pos; parse again with copy
+        try_parse_string(
+          current_token_start_pos, nullptr, nullptr, destination, write_style::unescaped);
+        return string_token_utf8_bytes;
+      case json_token::VALUE_NUMBER_INT:
+        if (number_token_len == 2 && current_token_start_pos[0] == '-' &&
+            current_token_start_pos[1] == '0') {
+          if (nullptr != destination) *destination++ = '0';
+          return 1;
+        }
+        if (nullptr != destination) {
+          for (cudf::size_type i = 0; i < number_token_len; ++i) {
+            *destination++ = *(current_token_start_pos + i);
+          }
+        }
+        return number_token_len;
+      case json_token::VALUE_NUMBER_FLOAT: {
+        // number normalization:
+        // 0.03E-2 => 0.3E-5; infinity;
+        // 200.000 => 200.0, 351.980 => 351.98, 12345678900000000000.0
+        // => 1.23456789E19 0.0000000000003 => 3.0E-13; 0.003 => 0.003; 0.0003
+        // => 3.0E-4 leverage function: `get_current_float_parts`
+        double d_value =
+          cudf::strings::detail::stod(cudf::string_view(current_token_start_pos, number_token_len));
+        return spark_rapids_jni::ftos_converter::double_normalization(d_value, destination);
+      }
+      case json_token::VALUE_TRUE:
+        if (nullptr != destination) {
+          *destination++ = 't';
+          *destination++ = 'r';
+          *destination++ = 'u';
+          *destination++ = 'e';
+        }
+        return 4;
+      case json_token::VALUE_FALSE:
+        if (nullptr != destination) {
+          *destination++ = 'f';
+          *destination++ = 'a';
+          *destination++ = 'l';
+          *destination++ = 's';
+          *destination++ = 'e';
+        }
+        return 5;
+      case json_token::VALUE_NULL:
+        if (nullptr != destination) {
+          *destination++ = 'n';
+          *destination++ = 'u';
+          *destination++ = 'l';
+          *destination++ = 'l';
+        }
+        return 4;
+      case json_token::FIELD_NAME:
+        // can not copy from JSON directly due to escaped chars
+        // rewind the pos; parse again with copy
+        try_parse_string(
+          current_token_start_pos, nullptr, nullptr, destination, write_style::unescaped);
+        return string_token_utf8_bytes;
+      case json_token::START_ARRAY:
+        if (nullptr != destination) { *destination++ = '['; }
+        return 1;
+      case json_token::END_ARRAY:
+        if (nullptr != destination) { *destination++ = ']'; }
+        return 1;
+      case json_token::START_OBJECT:
+        if (nullptr != destination) { *destination++ = '{'; }
+        return 1;
+      case json_token::END_OBJECT:
+        if (nullptr != destination) { *destination++ = '}'; }
+        return 1;
+      // for the following tokens, return false
+      case json_token::SUCCESS:
+      case json_token::ERROR:
+      case json_token::INIT: return 0;
+    }
+    return 0;
+  }
+
+  __device__ cudf::size_type compute_escaped_len() { return write_escaped_text(nullptr); }
+  /**
+   * escape current token text, then write to destination
+   * e.g.: '"' is a string with 1 char '"', writes out 4 chars '"' '\' '\"' '"'
+   * e.g.: "\u4e2d\u56FD" are code points for Chinese chars "中国",
+   *   writes 8 utf8 bytes: '"' -28  -72 -83 -27 -101 -67 '"'
+   * For number, write verbatim without normalization
+   */
+  __device__ cudf::size_type write_escaped_text(char* destination)
+  {
+    switch (curr_token) {
+      case json_token::VALUE_STRING:
+        // can not copy from JSON directly due to escaped chars
+        // rewind the pos; parse again with copy
+        try_parse_string(
+          current_token_start_pos, nullptr, nullptr, destination, write_style::escaped);
+        return string_token_utf8_bytes + bytes_diff_for_escape_writing;
+      case json_token::VALUE_NUMBER_INT:
+        if (number_token_len == 2 && current_token_start_pos[0] == '-' &&
+            current_token_start_pos[1] == '0') {
+          if (nullptr != destination) *destination++ = '0';
+          return 1;
+        }
+        if (nullptr != destination) {
+          for (cudf::size_type i = 0; i < number_token_len; ++i) {
+            *destination++ = *(current_token_start_pos + i);
+          }
+        }
+        return number_token_len;
+      case json_token::VALUE_NUMBER_FLOAT: {
+        double d_value =
+          cudf::strings::detail::stod(cudf::string_view(current_token_start_pos, number_token_len));
+        return spark_rapids_jni::ftos_converter::double_normalization(d_value, destination);
+      }
+      case json_token::VALUE_TRUE:
+        if (nullptr != destination) {
+          *destination++ = 't';
+          *destination++ = 'r';
+          *destination++ = 'u';
+          *destination++ = 'e';
+        }
+        return 4;
+      case json_token::VALUE_FALSE:
+        if (nullptr != destination) {
+          *destination++ = 'f';
+          *destination++ = 'a';
+          *destination++ = 'l';
+          *destination++ = 's';
+          *destination++ = 'e';
+        }
+        return 5;
+      case json_token::VALUE_NULL:
+        if (nullptr != destination) {
+          *destination++ = 'n';
+          *destination++ = 'u';
+          *destination++ = 'l';
+          *destination++ = 'l';
+        }
+        return 4;
+      case json_token::FIELD_NAME:
+        // can not copy from JSON directly due to escaped chars
+        // rewind the pos; parse again with copy
+        try_parse_string(
+          current_token_start_pos, nullptr, nullptr, destination, write_style::escaped);
+        return string_token_utf8_bytes + bytes_diff_for_escape_writing;
+      case json_token::START_ARRAY:
+        if (nullptr != destination) { *destination++ = '['; }
+        return 1;
+      case json_token::END_ARRAY:
+        if (nullptr != destination) { *destination++ = ']'; }
+        return 1;
+      case json_token::START_OBJECT:
+        if (nullptr != destination) { *destination++ = '{'; }
+        return 1;
+      case json_token::END_OBJECT:
+        if (nullptr != destination) { *destination++ = '}'; }
+        return 1;
+      // for the following tokens, return false
+      case json_token::SUCCESS:
+      case json_token::ERROR:
+      case json_token::INIT: return 0;
+    }
+    return 0;
+  }
+
+  /**
+   * reset the parser
+   */
+  __device__ void reset()
+  {
+    curr_pos   = json_start_pos;
+    curr_token = json_token::INIT;
+    stack_size = 0;
+  }
+
+  /**
+   * get float parts, current token should be VALUE_NUMBER_FLOAT.
+   */
+  __device__ thrust::tuple<bool, char const*, int, char const*, int, char const*, int>
+  get_current_float_parts()
+  {
+    return thrust::make_tuple(float_sign,
+                              float_integer_pos,
+                              float_integer_len,
+                              float_fraction_pos,
+                              float_fraction_len,
+                              float_exp_pos,
+                              float_exp_len);
+  }
+
+  /**
+   * match field name string when current token is FIELD_NAME,
+   * return true if current token is FIELD_NAME and match successfully.
+   * return false otherwise,
+   * Note: to_match_str_ptr should not be nullptr
+   */
+  __device__ bool match_current_field_name(cudf::string_view name)
+  {
+    return match_current_field_name(name.data(), name.size_bytes());
+  }
+
+  /**
+   * match current field name
+   */
+  __device__ bool match_current_field_name(char const* to_match_str_ptr, cudf::size_type len)
+  {
+    if (json_token::FIELD_NAME == curr_token) {
+      auto [b, end_pos] = try_parse_string(current_token_start_pos,
+                                           to_match_str_ptr,
+                                           to_match_str_ptr + len,
+                                           nullptr,
+                                           write_style::unescaped);
+      return b;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * copy current structure to destination.
+   * return false if meets JSON format error,
+   * reurn true otherwise.
+   * @param[out] copy_to
+   */
+  __device__ thrust::pair<bool, size_t> copy_current_structure(char* copy_to)
+  {
+    switch (curr_token) {
+      case json_token::INIT:
+      case json_token::ERROR:
+      case json_token::SUCCESS:
+      case json_token::FIELD_NAME:
+      case json_token::END_ARRAY:
+      case json_token::END_OBJECT: return thrust::make_pair(false, 0);
+      case json_token::VALUE_NUMBER_INT:
+      case json_token::VALUE_NUMBER_FLOAT:
+      case json_token::VALUE_STRING:
+      case json_token::VALUE_TRUE:
+      case json_token::VALUE_FALSE:
+      case json_token::VALUE_NULL:
+        // copy terminal token
+        if (nullptr != copy_to) {
+          size_t copy_len = write_escaped_text(copy_to);
+          return thrust::make_pair(true, copy_len);
+        } else {
+          size_t copy_len = compute_escaped_len();
+          return thrust::make_pair(true, copy_len);
+        }
+      case json_token::START_ARRAY:
+      case json_token::START_OBJECT:
+        // stack size increased by 1 when meet start object/array
+        // copy until meet matched end object/array
+        size_t sum_copy_len   = 0;
+        int backup_stack_size = stack_size;
+
+        // copy start object/array
+        if (nullptr != copy_to) {
+          int len = write_escaped_text(copy_to);
+          sum_copy_len += len;
+          copy_to += len;
+        } else {
+          sum_copy_len += compute_escaped_len();
+        }
+
+        while (true) {
+          bool has_comma_before_token = false;
+          bool has_colon_before_token = false;
+
+          // parse and get has_comma_before_token, has_colon_before_token
+          parse_next_token(has_comma_before_token, has_colon_before_token);
+
+          // check the JSON format
+          if (curr_token == json_token::ERROR) { return thrust::make_pair(false, 0); }
+
+          // write out the token
+          if (nullptr != copy_to) {
+            if (has_comma_before_token) {
+              sum_copy_len++;
+              *copy_to++ = ',';
+            }
+            if (has_colon_before_token) {
+              sum_copy_len++;
+              *copy_to++ = ':';
+            }
+            int len = write_escaped_text(copy_to);
+            sum_copy_len += len;
+            copy_to += len;
+          } else {
+            if (has_comma_before_token) { sum_copy_len++; }
+            if (has_colon_before_token) { sum_copy_len++; }
+            sum_copy_len += compute_escaped_len();
+          }
+
+          if (backup_stack_size - 1 == stack_size) {
+            // indicate meet the matched end object/array
+            return thrust::make_pair(true, sum_copy_len);
+          }
+        }
+        return thrust::make_pair(false, 0);
+    }
+
+    // never happen
+    return thrust::make_pair(false, 0);
+  }
+
+ private:
+  char const* const json_start_pos;
+  char const* const json_end_pos;
+  char const* curr_pos;
+  json_token curr_token{json_token::INIT};
+
+  // saves the nested contexts: JSON object context or JSON array context
+  // true is JSON object context; false is JSON array context
+  // When encounter EOF and this stack is non-empty, means non-closed JSON
+  // object/array, then parsing will fail.
+  bool context_stack[max_json_nesting_depth];
+  int stack_size = 0;
+
+  // save current token start pos, used by coping current row text
+  char const* current_token_start_pos;
+  // used to copy int/float string verbatim, note: int/float have no escape
+  // chars
+  cudf::size_type number_token_len;
+
+  // The following variables record number token informations.
+  // if current token is int/float, use the following variables to save
+  // float parts e.g.: -123.000456E-000789, sign is false; integer part is 123;
+  // fraction part is 000456; exp part is -000789. The following parts is used
+  // by normalization, e.g.: 0.001 => 1E-3
+  bool float_sign;
+  char const* float_integer_pos;
+  int float_integer_len;
+  char const* float_fraction_pos;
+  int float_fraction_len;
+  char const* float_exp_pos;
+  int float_exp_len;
+  // true indicates has '-' or '+' in the exp part;
+  // the exp sign char is not counted when checking the max number length
+  bool float_exp_has_sign;
+
+  // Records string/field name token utf8 bytes size after unescaped
+  // e.g.: For JSON string "\\n", after unescaped, it ues 1 byte '\n'
+  // used by `write_unescaped_text` and `write_escaped_text` bytes
+  // used by checking the max string length
+  int string_token_utf8_bytes;
+  // Records bytes diff for escape writing
+  // e.g.: "\\n" string_token_utf8_bytes is 1,
+  // when `write_escaped_text` bytes is 4: " \ n "
+  // this diff will be 4 - 1 = 3;
+  int bytes_diff_for_escape_writing;
+};
+
+}  // namespace spark_rapids_jni
diff --git a/src/main/java/com/nvidia/spark/rapids/jni/JSONUtils.java b/src/main/java/com/nvidia/spark/rapids/jni/JSONUtils.java
new file mode 100644
index 0000000000..bd034651b7
--- /dev/null
+++ b/src/main/java/com/nvidia/spark/rapids/jni/JSONUtils.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.nvidia.spark.rapids.jni;
+
+import ai.rapids.cudf.*;
+
+public class JSONUtils {
+  static {
+    NativeDepsLoader.loadNativeDeps();
+  }
+
+  public enum PathInstructionType {
+    SUBSCRIPT,
+    WILDCARD,
+    KEY,
+    INDEX,
+    NAMED
+  }
+
+  public static class PathInstructionJni {
+    // type: Int, name: String, index: Long
+    private final int type;
+    private final String name;
+    private final long index;
+
+    public PathInstructionJni(PathInstructionType type, String name, long index) {
+      this.type = type.ordinal();
+      this.name = name;
+      this.index = index;
+    }
+  }
+
+  public static ColumnVector getJsonObject(ColumnVector input, PathInstructionJni[] path_instructions) {
+    assert(input.getType().equals(DType.STRING)) : "column must be a String";
+    return new ColumnVector(getJsonObject(input.getNativeView(), path_instructions));
+  }
+
+  private static native long getJsonObject(long input, PathInstructionJni[] path_instructions);
+}
diff --git a/src/test/java/com/nvidia/spark/rapids/jni/GetJsonObjectTest.java b/src/test/java/com/nvidia/spark/rapids/jni/GetJsonObjectTest.java
new file mode 100644
index 0000000000..a5a519363b
--- /dev/null
+++ b/src/test/java/com/nvidia/spark/rapids/jni/GetJsonObjectTest.java
@@ -0,0 +1,602 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.nvidia.spark.rapids.jni;
+
+import ai.rapids.cudf.ColumnVector;
+import org.junit.jupiter.api.Test;
+
+import static ai.rapids.cudf.AssertUtils.assertColumnsAreEqual;
+
+public class GetJsonObjectTest {
+  /**
+   * Test: query is $.k
+   */
+  @Test
+  void getJsonObjectTest() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), namedPath("k") };
+    try (ColumnVector jsonCv = ColumnVector.fromStrings(
+        "{\"k\": \"v\"}");
+        ColumnVector expected = ColumnVector.fromStrings(
+            "v");
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test: query is $.k1
+   */
+  @Test
+  void getJsonObjectTest2() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(),
+        namedPath("k1_111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111")
+    };
+
+    String JSON = "{\"k1_111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111\""
+        +
+        ":\"v1_111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111\"}";
+    String expectedStr = "v1_111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(
+            JSON, JSON, JSON, JSON, JSON, JSON, JSON);
+        ColumnVector expected = ColumnVector.fromStrings(
+            expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test: query is $.k1.k2
+   */
+  @Test
+  void getJsonObjectTest3() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), namedPath("k1"), keyPath(), namedPath("k2")
+    };
+    String JSON = "{\"k1\":{\"k2\":\"v2\"}}";
+    String expectedStr = "v2";
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(
+            JSON, JSON, JSON, JSON, JSON, JSON, JSON);
+        ColumnVector expected = ColumnVector.fromStrings(
+            expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test: query paths depth is 10
+   */
+  @Test
+  void getJsonObjectTest4() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), namedPath("k1"),
+        keyPath(), namedPath("k2"),
+        keyPath(), namedPath("k3"),
+        keyPath(), namedPath("k4"),
+        keyPath(), namedPath("k5"),
+        keyPath(), namedPath("k6"),
+        keyPath(), namedPath("k7"),
+        keyPath(), namedPath("k8"),
+        keyPath(), namedPath("k9"),
+        keyPath(), namedPath("k10")
+    };
+
+    String JSON = "{\"k1\":{\"k2\":{\"k3\":{\"k4\":{\"k5\":{\"k6\":{\"k7\":{\"k8\":{\"k9\":{\"k10\":\"v10\"}}}}}}}}}}";
+    String expectedStr = "v10";
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(
+            JSON, JSON, JSON, JSON, JSON, JSON, JSON);
+        ColumnVector expected = ColumnVector.fromStrings(
+            expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Baidu case: unescape http:\\/\\/ to http://
+   */
+  @Test
+  void getJsonObjectTest_Baidu_unescape_backslash() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), namedPath("URdeosurl")
+    };
+
+    String JSON = "{\"brand\":\"ssssss\",\"duratRon\":15,\"eqTosuresurl\":\"\",\"RsZxarthrl\":false,\"xonRtorsurl\":\"\",\"xonRtorsurlstOTe\":0,\"TRctures\":[{\"RxaGe\":\"VttTs:\\/\\/feed-RxaGe.baRdu.cox\\/0\\/TRc\\/-196588744s840172444s-773690137.zTG\"}],\"Toster\":\"VttTs:\\/\\/feed-RxaGe.baRdu.cox\\/0\\/TRc\\/-196588744s840172444s-773690137.zTG\",\"reserUed\":{\"bRtLate\":391.79,\"xooUZRke\":26876,\"nahrlIeneratRonNOTe\":0,\"useJublRc\":6,\"URdeoRd\":821284086},\"tRtle\":\"ssssssssssmMsssssssssssssssssss\",\"url\":\"s{storehrl}\",\"usersTortraRt\":\"VttTs:\\/\\/feed-RxaGe.baRdu.cox\\/0\\/TRc\\/-6971178959s-664926866s-6096674871.zTG\",\"URdeosurl\":\"http:\\/\\/nadURdeo2.baRdu.cox\\/5fa3893aed7fc0f8231dab7be23efc75s820s6240.xT3\",\"URdeoRd\":821284086}";
+    String expectedStr = "http://nadURdeo2.baRdu.cox/5fa3893aed7fc0f8231dab7be23efc75s820s6240.xT3";
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(
+            JSON, JSON, JSON, JSON, JSON, JSON, JSON);
+        ColumnVector expected = ColumnVector.fromStrings(
+            expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr, expectedStr);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Baidu case: query unexist field name
+   */
+  @Test
+  void getJsonObjectTest_Baidu_get_unexist_field_name() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), namedPath("Vgdezsurl")
+    };
+
+    String JSON = "{\"brand\":\"ssssss\",\"duratgzn\":17,\"eSyzsuresurl\":\"\",\"gswUartWrl\":false,\"Uzngtzrsurl\":\"\",\"UzngtzrsurlstJye\":0,\"ygctures\":[{\"gUaqe\":\"Ittys:\\/\\/feed-gUaqe.bagdu.czU\\/0\\/ygc\\/63025364s-376461312s7528698939.Qyq\"}],\"yzster\":\"Ittys:\\/\\/feed-gUaqe.bagdu.czU\\,\"url\":\"s{stHreqrl}\",\"usersPHrtraIt\":\"LttPs:\\/\\/feed-IUaxe.baIdu.cHU\\/0\\/PIc\\/-1043913002s489796992s-1505641721.Pnx\",\"kIdeHsurl\":\"LttP:\\/\\/nadkIdeH9.baIdu.cHU\\/4d7d308bd7c04e63069fd343adfa792as1790s1080.UP3\",\"kIdeHId\":852890923}";
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(
+            JSON, JSON, JSON, JSON, JSON, JSON, JSON);
+        ColumnVector expected = ColumnVector.fromStrings(
+            null, null, null, null, null, null, null);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * test escape chars:
+   * 1. " in ' pair
+   * 2. ' in " pair
+   * 3. \ / " ' \b \f \n \r \t
+   * 4. \ u HEX HEX HEX HEX: code point
+   */
+  @Test
+  void getJsonObjectTest_Escape() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[0];
+
+    String JSON1 = "{ \"a\": \"A\" }";
+    String JSON2 = "{'a':'A\"'}";
+    String JSON3 = "{'a':\"B'\"}";
+    String JSON4 = "['a','b','\"C\"']";
+    // \\u4e2d\\u56FD is 中国
+    String JSON5 = "'\\u4e2d\\u56FD\\\"\\'\\\\\\/\\b\\f\\n\\r\\t\\b'";
+
+    String expectedStr1 = "{\"a\":\"A\"}";
+    String expectedStr2 = "{\"a\":\"A\\\"\"}";
+    String expectedStr3 = "{\"a\":\"B'\"}";
+    String expectedStr4 = "[\"a\",\"b\",\"\\\"C\\\"\"]";
+    String expectedStr5 = "中国\"'\\/\b\f\n\r\t\b";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(
+            JSON1, JSON2, JSON3, JSON4, JSON5);
+        ColumnVector expected = ColumnVector.fromStrings(
+            expectedStr1, expectedStr2, expectedStr3, expectedStr4, expectedStr5);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * test number normalizations
+   */
+  @Test
+  void getJsonObjectTest_Number_Normalization() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[0];
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(
+            "[100.0,200.000,351.980]",
+            "[12345678900000000000.0]",
+            "[0.0]",
+            "[-0.0]",
+            "[-0]",
+            "[12345678999999999999999999]",
+            "[1E308]",
+            "[1.0E309,-1E309,1E5000]",
+            "0.3",
+            "0.03",
+            "0.003",
+            "0.0003",
+            "0.00003");
+        ColumnVector expected = ColumnVector.fromStrings(
+            "[100.0,200.0,351.98]",
+            "[1.23456789E19]",
+            "[0.0]",
+            "[-0.0]",
+            "[0]",
+            "[12345678999999999999999999]",
+            "[1.0E308]",
+            "[\"Infinity\",\"-Infinity\",\"Infinity\"]",
+            "0.3",
+            "0.03",
+            "0.003",
+            "3.0E-4",
+            "3.0E-5");
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test number:
+   * leading zeros are invalid: 00, 01, 02, 000, -01, -00, -02
+   */
+  @Test
+  void getJsonObjectTest_Test_leading_zeros() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[0];
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings("00", "01", "02", "000", "-01", "-00", "-02");
+        ColumnVector expected = ColumnVector.fromStrings(null, null, null, null, null, null, null);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test $[1]
+   */
+  @Test
+  void getJsonObjectTest_Test_index() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), indexPath(1)
+    };
+
+    String JSON1 = "[ [0, 1, 2] , [10, [11], [121, 122, 123], 13] ,  [20, 21, 22]]";
+    String expectedStr1 = "[10,[11],[121,122,123],13]";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test $[1][2]
+   */
+  @Test
+  void getJsonObjectTest_Test_index_index() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), indexPath(1), subscriptPath(), indexPath(2)
+    };
+
+    String JSON1 = "[ [0, 1, 2] , [10, [11], [121, 122, 123], 13] ,  [20, 21, 22]]";
+    String expectedStr1 = "[121,122,123]";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 1: case (VALUE_STRING, Nil) if style == RawStyle
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path1() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[0];
+
+    String JSON1 = "'abc'";
+    String expectedStr1 = "abc";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 5: case (START_ARRAY, Subscript :: Wildcard :: Subscript ::
+   * Wildcard :: xs), set flatten style
+   * case path 2: case (START_ARRAY, Nil) if style == FlattenStyle
+   * 
+   * First use path5 [*][*] to enable flatten style.
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path2() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), wildcardPath(), subscriptPath(), wildcardPath()
+    };
+
+    String JSON1 = "[ [11, 12], [21, [221, [2221, [22221, 22222]]]], [31, 32] ]";
+    String expectedStr1 = "[11,12,21,221,2221,22221,22222,31,32]";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 3: case (_, Nil)
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path3() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[0];
+
+    String JSON1 = "123";
+    String expectedStr1 = "123";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 4: case (START_OBJECT, Key :: xs)
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path4() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), namedPath("k")
+    };
+
+    String JSON1 = "{ 'k' : 'v'  }";
+    String expectedStr1 = "v";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 5: case (START_ARRAY, Subscript :: Wildcard :: Subscript ::
+   * Wildcard :: xs), set flatten style
+   * case path 4: case (START_OBJECT, Key :: xs)
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path5() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), wildcardPath(), subscriptPath(), wildcardPath(), // $[*][*]
+        keyPath(), namedPath("k")
+    };
+
+    // flatten the arrays, then query named path "k"
+    String JSON1 = "[  [[[ {'k': 'v1'} ], {'k': 'v2'}]], [[{'k': 'v3'}], {'k': 'v4'}], {'k': 'v5'}  ]";
+    String expectedStr1 = "[\"v5\"]";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 6: case (START_ARRAY, Subscript :: Wildcard :: xs) if style !=
+   * QuotedStyle
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path6() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), wildcardPath()
+    };
+    String JSON1 = "[1, [21, 22], 3]";
+    String expectedStr1 = "[1,[21,22],3]";
+
+    String JSON2 = "[1]";
+    String expectedStr2 = "1"; // note: in row mode, if it has only 1 item, then remove the outer: []
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1, JSON2);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1, expectedStr2);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 6: case (START_ARRAY, Subscript :: Wildcard :: xs) if style !=
+   * QuotedStyle, after this path, style is quoted mode
+   * case path 4: case (START_OBJECT, Key :: xs)
+   * case path 10: case (FIELD_NAME, Named(name) :: xs) if p.getCurrentName ==
+   * name
+   * case path 7: case (START_ARRAY, Subscript :: Wildcard :: xs), test quoted
+   * mode
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path7() {
+    // subscriptPath(), wildcardPath() subscriptPath(), wildcardPath() will go to
+    // path5
+    // so insert keyPath(), namedPath("k")
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), wildcardPath(), // path 6
+        keyPath(), namedPath("k"), // path 4, path 10
+        subscriptPath(), wildcardPath() // path 7
+    };
+
+    String JSON1 = "[ {'k': [0, 1, 2]}, {'k': [10, 11, 12]}, {'k': [20, 21, 22]}  ]";
+    String expectedStr1 = "[[0,1,2],[10,11,12],[20,21,22]]";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 8: case (START_ARRAY, Subscript :: Index(idx) :: (xs@Subscript ::
+   * Wildcard :: _))
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path8() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), indexPath(1), subscriptPath(), wildcardPath()
+    };
+    String JSON1 = "[ [0], [10, 11, 12], [2] ]";
+    String expectedStr1 = "[10,11,12]";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 9: case (START_ARRAY, Subscript :: Index(idx) :: xs)
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path9() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), indexPath(1), subscriptPath(), indexPath(1), subscriptPath(), wildcardPath()
+    };
+    String JSON1 = "[[0, 1, 2], [10, [111, 112, 113], 12], [20, 21, 22]]";
+    String expectedStr1 = "[111,112,113]";
+    String JSON2 = "[[0, 1, 2], [10, [], 12], [20, 21, 22]]";
+    String expectedStr2 = null;
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1, JSON2);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1, expectedStr2);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 10: case (FIELD_NAME, Named(name) :: xs) if p.getCurrentName ==
+   * name
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path10() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), namedPath("k"), subscriptPath(), indexPath(1)
+    };
+    String JSON1 = "{'k' : [0,1,2]}";
+    String expectedStr1 = "1";
+    String JSON2 = "{'k' : null}";
+    String expectedStr2 = null; // return false
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1, JSON2);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1, expectedStr2);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 11: case (FIELD_NAME, Wildcard :: xs)
+   * Refer to Spark code:
+   * https://github.com/apache/spark/blob/v3.5.0/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/jsonExpressions.scala#L218
+   * path sequence key, wildcard can test path 11, but parser can not produce this
+   * sequence.
+   * Note: Here use manually created key, wildcard sequence to test.
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path11() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        keyPath(), wildcardPath()
+    };
+    String JSON1 = "{'k' : [0,1,2]}";
+    String expectedStr1 = "[0,1,2]";
+    String JSON2 = "{'k' : null}";
+    String expectedStr2 = "null";
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1, JSON2);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1, expectedStr2);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Test case paths:
+   * case path 12: case _
+   */
+  @Test
+  void getJsonObjectTest_Test_case_path12() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        wildcardPath()
+    };
+    String JSON1 = "123";
+    String expectedStr1 = null;
+
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  /**
+   * Query: $[*][*][*]
+   */
+  @Test
+  void getJsonObjectTest_Test_insert_comma_insert_outer_array() {
+    JSONUtils.PathInstructionJni[] query = new JSONUtils.PathInstructionJni[] {
+        subscriptPath(), wildcardPath(), subscriptPath(), wildcardPath(), subscriptPath(), wildcardPath()
+    };
+    String JSON1 = "[ [11, 12], [21, 22]]";
+    String expectedStr1 = "[[11,12],[21,22]]";
+    String JSON2 = "[ [11], [22] ]";
+    String expectedStr2 = "[11,22]";
+    try (
+        ColumnVector jsonCv = ColumnVector.fromStrings(JSON1, JSON2);
+        ColumnVector expected = ColumnVector.fromStrings(expectedStr1, expectedStr2);
+        ColumnVector actual = JSONUtils.getJsonObject(jsonCv, query)) {
+      assertColumnsAreEqual(expected, actual);
+    }
+  }
+
+  private JSONUtils.PathInstructionJni keyPath() {
+    return new JSONUtils.PathInstructionJni(JSONUtils.PathInstructionType.KEY, "", -1);
+  }
+
+  private JSONUtils.PathInstructionJni subscriptPath() {
+    return new JSONUtils.PathInstructionJni(JSONUtils.PathInstructionType.SUBSCRIPT, "", -1);
+  }
+
+  private JSONUtils.PathInstructionJni wildcardPath() {
+    return new JSONUtils.PathInstructionJni(JSONUtils.PathInstructionType.WILDCARD, "", -1);
+  }
+
+  private JSONUtils.PathInstructionJni namedPath(String name) {
+    return new JSONUtils.PathInstructionJni(JSONUtils.PathInstructionType.NAMED, name, -1);
+  }
+
+  private JSONUtils.PathInstructionJni indexPath(int index) {
+    return new JSONUtils.PathInstructionJni(JSONUtils.PathInstructionType.INDEX, "", index);
+  }
+}

From ffcb14b7e73702e32e3907301e2c4d588543c256 Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Thu, 28 Mar 2024 05:59:50 +0800
Subject: [PATCH 125/132] Update submodule cudf to
 35f818b3e4bef8e331f083dadc9a4c45e2987a78 (#1913)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index e3cbf62fce..35f818b3e4 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit e3cbf62fcef479a051d116c451e69ddaa4568b57
+Subproject commit 35f818b3e4bef8e331f083dadc9a4c45e2987a78

From 7559c881701952d9a346821359451d8ef756e8f6 Mon Sep 17 00:00:00 2001
From: Alessandro Bellina <abellina@nvidia.com>
Date: Mon, 1 Apr 2024 13:28:06 -0500
Subject: [PATCH 126/132] Set LIBCUDF_LOGGING_LEVEL to allow us to turn off rmm
 log (#1918)

* Set LIBCUDF_LOGGING_LEVEL to allow us to turn off rmm log

Signed-off-by: Alessandro Bellina <abellina@nvidia.com>

* Update copyright

---------

Signed-off-by: Alessandro Bellina <abellina@nvidia.com>
---
 build-libcudf.xml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/build-libcudf.xml b/build-libcudf.xml
index f4068c180d..e35c3cec14 100644
--- a/build-libcudf.xml
+++ b/build-libcudf.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0"?>
 <!--
-  Copyright (c) 2022, NVIDIA CORPORATION.
+  Copyright (c) 2022-2024, NVIDIA CORPORATION.
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -45,6 +45,7 @@
       <arg value="-DCUDF_ENABLE_ARROW_PARQUET=ON"/>
       <arg value="-DCUDF_USE_ARROW_STATIC=ON"/>
       <arg value="-DCUDF_USE_PER_THREAD_DEFAULT_STREAM=${CUDF_USE_PER_THREAD_DEFAULT_STREAM}" />
+      <arg value="-DLIBCUDF_LOGGING_LEVEL=${RMM_LOGGING_LEVEL}" />
       <arg value="-DRMM_LOGGING_LEVEL=${RMM_LOGGING_LEVEL}" />
       <arg value="-DUSE_GDS=${USE_GDS}" />
     </exec>

From fa7c2020ae5c8012ae1a520359c5095a4465108f Mon Sep 17 00:00:00 2001
From: Jason Lowe <jlowe@nvidia.com>
Date: Tue, 2 Apr 2024 13:42:47 -0500
Subject: [PATCH 127/132] Pin cudf dependencies during build (#1901)

* Support cudf pin with rapids-cmake (#1877)

* Use rapids-cmake to pin cudf dependencies to known working SHA1's

* Use git download rapids-cmake

So that we can get SHA
Use same format of CopyRight
Use cudf/rapids_config.cmake which is renamed from fetch_rapids.cmake
Update versions to latest

Signed-off-by: Gary Shen <gashen@nvidia.com>

* Commit cudf to the latest code before mvn verify

Signed-off-by: Gary Shen <gashen@nvidia.com>

* Remove the first commit of cudf

since the second one can commit it at once

Signed-off-by: Gary Shen <gashen@nvidia.com>

---------

Signed-off-by: Gary Shen <gashen@nvidia.com>
Co-authored-by: Robert Maynard <rmaynard@nvidia.com>

* Update cudf pin versions

Signed-off-by: Jason Lowe <jlowe@nvidia.com>

* Update pin versions

Signed-off-by: Jason Lowe <jlowe@nvidia.com>

---------

Signed-off-by: Gary Shen <gashen@nvidia.com>
Signed-off-by: Jason Lowe <jlowe@nvidia.com>
Co-authored-by: Gary Shen <gashen@nvidia.com>
Co-authored-by: Robert Maynard <rmaynard@nvidia.com>
---
 build-libcudf.xml                             |   2 +
 ci/submodule-sync.sh                          |  15 +-
 pom.xml                                       |   2 +
 .../cudf-pins/add_dependency_pins.cmake       |  37 +++++
 thirdparty/cudf-pins/rapids-cmake.sha         |   1 +
 thirdparty/cudf-pins/setup.cmake              |  45 +++++
 thirdparty/cudf-pins/versions.json            | 155 ++++++++++++++++++
 7 files changed, 255 insertions(+), 2 deletions(-)
 create mode 100644 thirdparty/cudf-pins/add_dependency_pins.cmake
 create mode 100644 thirdparty/cudf-pins/rapids-cmake.sha
 create mode 100644 thirdparty/cudf-pins/setup.cmake
 create mode 100644 thirdparty/cudf-pins/versions.json

diff --git a/build-libcudf.xml b/build-libcudf.xml
index e35c3cec14..765f50e8a0 100644
--- a/build-libcudf.xml
+++ b/build-libcudf.xml
@@ -40,6 +40,7 @@
       <arg value="-DBUILD_TESTS=OFF"/>
       <arg value="-DCMAKE_CUDA_ARCHITECTURES=${GPU_ARCHS}"/>
       <arg value="-DCMAKE_INSTALL_PREFIX=${libcudf.install.path}"/>
+      <arg value="-DCUDF_DEPENDENCY_PIN_MODE=${libcudf.dependency.mode}"/>
       <arg value="-DCUDA_STATIC_RUNTIME=ON"/>
       <arg value="-DCUDF_ENABLE_ARROW_S3=OFF"/>
       <arg value="-DCUDF_ENABLE_ARROW_PARQUET=ON"/>
@@ -48,6 +49,7 @@
       <arg value="-DLIBCUDF_LOGGING_LEVEL=${RMM_LOGGING_LEVEL}" />
       <arg value="-DRMM_LOGGING_LEVEL=${RMM_LOGGING_LEVEL}" />
       <arg value="-DUSE_GDS=${USE_GDS}" />
+      <arg value="-C=${cudf.pin.path}/setup.cmake"/>
     </exec>
 
     <exec dir="${libcudf.build.path}"
diff --git a/ci/submodule-sync.sh b/ci/submodule-sync.sh
index 8822b3cf7b..18119dc45d 100755
--- a/ci/submodule-sync.sh
+++ b/ci/submodule-sync.sh
@@ -65,8 +65,6 @@ fi
 
 echo "Try update cudf submodule to ${cudf_sha}..."
 git add .
-git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${CUDF_TAG:-$cudf_sha}"
-sha=$(git rev-parse HEAD)
 
 echo "Test against ${cudf_sha}..."
 
@@ -75,6 +73,7 @@ set +e
 ${MVN} verify ${MVN_MIRROR} \
   -DCPP_PARALLEL_LEVEL=${PARALLEL_LEVEL} \
   -Dlibcudf.build.configure=true \
+  -Dlibcudf.dependency.mode=latest \
   -DUSE_GDS=ON -Dtest=*,!CuFileTest,!CudaFatalTest,!ColumnViewNonEmptyNullsTest \
   -DBUILD_TESTS=ON \
   -DUSE_SANITIZER=ON
@@ -89,6 +88,18 @@ else
   echo "Test failed, will update the result"
 fi
 
+# Extract the rapids-cmake sha1 that we need to pin too
+rapids_cmake_sha=$(git -C thirdparty/cudf/cpp/build/_deps/rapids-cmake-src/ rev-parse HEAD)
+echo "Update rapids-cmake pinned SHA1 to ${rapids_cmake_sha}"
+echo "${rapids_cmake_sha}" > thirdparty/cudf-pins/rapids-cmake.sha
+
+# Do the git add after the build so that we get
+# the updated versions.json generated by the build
+echo "Update cudf submodule to ${cudf_sha} with updated pinned versions"
+git add .
+git diff-index --quiet HEAD || git commit -s -m "Update submodule cudf to ${cudf_sha}"
+sha=$(git rev-parse HEAD)
+
 # push the intermediate branch and create PR against REF
 # if test passed, it will try auto-merge the PR
 # if test failed, it will only comment the test result in the PR
diff --git a/pom.xml b/pom.xml
index f7a4fcd354..8dca17cf3e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -89,12 +89,14 @@
     <cuda.version>cuda11</cuda.version>
     <jni.classifier>${cuda.version}</jni.classifier>
     <cudf.path>${project.basedir}/thirdparty/cudf</cudf.path>
+    <cudf.pin.path>${project.basedir}/thirdparty/cudf-pins/</cudf.pin.path>
     <hadoop.version>3.2.4</hadoop.version>
     <junit.version>5.8.1</junit.version>
     <libcudf.build.path>${cudf.path}/cpp/build</libcudf.build.path>
     <libcudf.build.configure>false</libcudf.build.configure>
     <libcudf.clean.skip>true</libcudf.clean.skip>
     <libcudf.install.path>${project.build.directory}/libcudf-install</libcudf.install.path>
+    <libcudf.dependency.mode>pinned</libcudf.dependency.mode>
     <libcudfjni.build.path>${project.build.directory}/libcudfjni</libcudfjni.build.path>
     <maven.compiler.source>1.8</maven.compiler.source>
     <maven.compiler.target>1.8</maven.compiler.target>
diff --git a/thirdparty/cudf-pins/add_dependency_pins.cmake b/thirdparty/cudf-pins/add_dependency_pins.cmake
new file mode 100644
index 0000000000..73e0ebab76
--- /dev/null
+++ b/thirdparty/cudf-pins/add_dependency_pins.cmake
@@ -0,0 +1,37 @@
+#
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+if(NOT DEFINED rapids-cmake-dir)
+  include(../cudf/rapids_config.cmake)
+endif()
+
+include(rapids-cpm)
+rapids_cpm_init()
+
+function(add_override_if_requested)
+  if(CUDF_DEPENDENCY_PIN_MODE STREQUAL pinned)
+    include(${rapids-cmake-dir}/cpm/package_override.cmake)
+    rapids_cpm_package_override(${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json)
+
+    message(STATUS "Pinning CUDF dependencies to values found in ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json")
+  else()
+    include(${rapids-cmake-dir}/cpm/generate_pinned_versions.cmake)
+    rapids_cpm_generate_pinned_versions(OUTPUT ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json)
+
+    message(STATUS "Building with latest CUDF dependencies (saving pinned versions to ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/versions.json)")
+  endif()
+endfunction()
+add_override_if_requested()
diff --git a/thirdparty/cudf-pins/rapids-cmake.sha b/thirdparty/cudf-pins/rapids-cmake.sha
new file mode 100644
index 0000000000..fd9b77a7c7
--- /dev/null
+++ b/thirdparty/cudf-pins/rapids-cmake.sha
@@ -0,0 +1 @@
+096ae3c0a6b2c593f8fdb38468be527027bf79d7
diff --git a/thirdparty/cudf-pins/setup.cmake b/thirdparty/cudf-pins/setup.cmake
new file mode 100644
index 0000000000..8040c26faf
--- /dev/null
+++ b/thirdparty/cudf-pins/setup.cmake
@@ -0,0 +1,45 @@
+#
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+string(TOLOWER "${CUDF_DEPENDENCY_PIN_MODE}" CUDF_DEPENDENCY_PIN_MODE)
+if(NOT (CUDF_DEPENDENCY_PIN_MODE STREQUAL pinned OR
+        CUDF_DEPENDENCY_PIN_MODE STREQUAL latest))
+  message(FATAL_ERROR "The CUDF_DEPENDENCY_PIN_MODE variable must be set to either `pinned` or `latest`.")
+ endif()
+
+function(set_rapids_cmake_pin_sha1)
+  set(rapids-cmake-sha "${rapids-cmake-sha}" PARENT_SCOPE)
+
+  message(STATUS "Pinning rapids-cmake SHA1 to ${rapids-cmake-sha}")
+endfunction()
+
+# We need to set the rapids-cmake SHA1 before any CMake code in libcudf is executed when
+# we are in pin mode. Otherwise we will use the latest rapids-cmake version since that
+# is what cudf does via `fetch_rapids.cmake`
+if(CUDF_DEPENDENCY_PIN_MODE STREQUAL pinned)
+  # Extract the rapids sha1 from the file
+  file(READ "${CMAKE_CURRENT_LIST_DIR}/rapids-cmake.sha" rapids-cmake-sha)
+  string(STRIP rapids-cmake-sha "${rapids-cmake-sha}")
+  string(REPLACE "\n" "" rapids-cmake-sha "${rapids-cmake-sha}")
+  set(rapids-cmake-sha "${rapids-cmake-sha}" CACHE STRING "rapids-cmake sha to use" FORCE)
+  message(STATUS "Pinning rapids-cmake SHA1 [${rapids-cmake-sha}]")
+else()
+  set(rapids-cmake-fetch-via-git "ON" CACHE STRING "Make sure rapids-cmake is cloned so we can get SHA value" FORCE)
+endif()
+
+# We need to use a project() call hook, since rapids-cmake cpm_init()
+# can't be called from a `-C` CMake file
+set(CMAKE_PROJECT_TOP_LEVEL_INCLUDES "${CMAKE_CURRENT_LIST_DIR}/add_dependency_pins.cmake" CACHE FILEPATH "" )
diff --git a/thirdparty/cudf-pins/versions.json b/thirdparty/cudf-pins/versions.json
new file mode 100644
index 0000000000..f8e4379cd4
--- /dev/null
+++ b/thirdparty/cudf-pins/versions.json
@@ -0,0 +1,155 @@
+{
+  "packages" : 
+  {
+    "Arrow" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "740889f413af9b1ae1d81eb1e5a4a9fb4ce9cf97",
+      "git_url" : "https://github.com/apache/arrow.git",
+      "version" : "14.0.2"
+    },
+    "CCCL" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "36f379f29660761fe033a1306ca9dab6a88cb65c",
+      "git_url" : "https://github.com/NVIDIA/cccl.git",
+      "patches" : 
+      [
+        {
+          "file" : "cccl/bug_fixes.diff",
+          "fixed_in" : "2.3",
+          "issue" : "CCCL installs header-search.cmake files in nondeterministic order and has a typo in checking target creation that leads to duplicates"
+        },
+        {
+          "file" : "cccl/hide_kernels.diff",
+          "fixed_in" : "2.3",
+          "issue" : "Mark all cub and thrust kernels with hidden visibility [https://github.com/nvidia/cccl/pulls/443]"
+        },
+        {
+          "file" : "cccl/revert_pr_211.diff",
+          "fixed_in" : "",
+          "issue" : "thrust::copy introduced a change in behavior that causes failures with cudaErrorInvalidValue."
+        },
+        {
+          "file" : "${current_json_dir}/thrust_disable_64bit_dispatching.diff",
+          "fixed_in" : "",
+          "issue" : "Remove 64bit dispatching as not needed by libcudf and results in compiling twice as many kernels [https://github.com/rapidsai/cudf/pull/11437]"
+        },
+        {
+          "file" : "${current_json_dir}/thrust_faster_sort_compile_times.diff",
+          "fixed_in" : "",
+          "issue" : "Improve Thrust sort compile times by not unrolling loops for inlined comparators [https://github.com/rapidsai/cudf/pull/10577]"
+        },
+        {
+          "file" : "${current_json_dir}/thrust_faster_scan_compile_times.diff",
+          "fixed_in" : "",
+          "issue" : "Improve Thrust scan compile times by reducing the number of kernels generated [https://github.com/rapidsai/cudf/pull/8183]"
+        }
+      ],
+      "version" : "2.2.0"
+    },
+    "GTest" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "b796f7d44681514f58a683a3a71ff17c94edb0c1",
+      "git_url" : "https://github.com/google/googletest.git",
+      "version" : "1.13.0"
+    },
+    "KvikIO" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "c98eabbad1f60dfe640d03f03a2df58b23f3e167",
+      "git_url" : "https://github.com/rapidsai/kvikio.git",
+      "version" : "24.04"
+    },
+    "NVTX3" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "e170594ac7cf1dac584da473d4ca9301087090c1",
+      "git_url" : "https://github.com/NVIDIA/NVTX.git",
+      "version" : "3.1.0"
+    },
+    "cuco" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "56c53beb6fb0cafd265b7fcc3df78ae487811b22",
+      "git_url" : "https://github.com/NVIDIA/cuCollections.git",
+      "version" : "0.0.1"
+    },
+    "dlpack" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "365b823cedb281cd0240ca601aba9b78771f91a3",
+      "git_url" : "https://github.com/dmlc/dlpack.git",
+      "version" : "0.8"
+    },
+    "fmt" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "f5e54359df4c26b6230fc61d38aa294581393084",
+      "git_url" : "https://github.com/fmtlib/fmt.git",
+      "patches" : 
+      [
+        {
+          "file" : "fmt/fix_10_1_1_version.diff",
+          "fixed_in" : "10.2.0",
+          "issue" : "fmt 10.1.1 produces a CMake package with version 10.1.0"
+        }
+      ],
+      "version" : "10.1.1"
+    },
+    "jitify" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "047df5e87d84834f8f4225898476145741acfa80",
+      "git_url" : "https://github.com/rapidsai/jitify.git",
+      "version" : "2.0.0"
+    },
+    "nvcomp" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "v2.2.0",
+      "git_url" : "https://github.com/NVIDIA/nvcomp.git",
+      "proprietary_binary" : 
+      {
+        "aarch64-linux" : "https://developer.download.nvidia.com/compute/nvcomp/${version}/local_installers/nvcomp_${version}_SBSA_${cuda-toolkit-version-major}.x.tgz",
+        "x86_64-linux" : "https://developer.download.nvidia.com/compute/nvcomp/${version}/local_installers/nvcomp_${version}_x86_64_${cuda-toolkit-version-major}.x.tgz"
+      },
+      "version" : "3.0.6"
+    },
+    "rmm" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "0651edf0fce5ebf53528382b475fc29a2f3afa67",
+      "git_url" : "https://github.com/rapidsai/rmm.git",
+      "version" : "24.04"
+    },
+    "spdlog" : 
+    {
+      "always_download" : true,
+      "git_shallow" : false,
+      "git_tag" : "7e635fca68d014934b4af8a1cf874f63989352b7",
+      "git_url" : "https://github.com/gabime/spdlog.git",
+      "patches" : 
+      [
+        {
+          "file" : "spdlog/nvcc_constexpr_fix.diff",
+          "fixed_in" : "1.13",
+          "issue" : "Fix constexpr mismatch between spdlog and fmt [https://github.com/gabime/spdlog/issues/2856]"
+        }
+      ],
+      "version" : "1.12.0"
+    }
+  }
+}
\ No newline at end of file

From d853c259a75a79328631b746182a2ad72d54ccbf Mon Sep 17 00:00:00 2001
From: YanxuanLiu <104543031+YanxuanLiu@users.noreply.github.com>
Date: Mon, 8 Apr 2024 09:27:04 +0800
Subject: [PATCH 128/132] Update actions version [skip ci] (#1898)

* change container name

Signed-off-by: YanxuanLiu <yanxuanl@nvidia.com>

* update actions version

Signed-off-by: YanxuanLiu <yanxuanl@nvidia.com>

* update 2024 copyright

Signed-off-by: YanxuanLiu <yanxuanl@nvidia.com>

---------

Signed-off-by: YanxuanLiu <yanxuanl@nvidia.com>
---
 .github/workflows/add-to-project.yml | 4 ++--
 .github/workflows/auto-merge.yml     | 2 +-
 .github/workflows/blossom-ci.yml     | 4 ++--
 .github/workflows/clang-format.yml   | 4 ++--
 .github/workflows/signoff-check.yml  | 4 ++--
 5 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/add-to-project.yml b/.github/workflows/add-to-project.yml
index 939fa60434..5942e13266 100644
--- a/.github/workflows/add-to-project.yml
+++ b/.github/workflows/add-to-project.yml
@@ -1,4 +1,4 @@
-# Copyright (c) 2022-2023, NVIDIA CORPORATION.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -28,7 +28,7 @@ jobs:
     name: Add new issues and pull requests to project
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/add-to-project@v0.4.0
+      - uses: actions/add-to-project@v0.6.1
         with:
           project-url: https://github.com/orgs/NVIDIA/projects/4
           github-token: ${{ secrets.PROJECT_TOKEN }}
diff --git a/.github/workflows/auto-merge.yml b/.github/workflows/auto-merge.yml
index 4551103779..fc1b22e3c2 100755
--- a/.github/workflows/auto-merge.yml
+++ b/.github/workflows/auto-merge.yml
@@ -31,7 +31,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           ref: ${{ env.HEAD }} # force to fetch from latest upstream instead of PR ref
           token: ${{ secrets.AUTOMERGE_TOKEN }} # workaround auto-merge token to avoid GITHUB_TOKEN insufficient permission
diff --git a/.github/workflows/blossom-ci.yml b/.github/workflows/blossom-ci.yml
index ece14b4201..2d09c02be0 100644
--- a/.github/workflows/blossom-ci.yml
+++ b/.github/workflows/blossom-ci.yml
@@ -81,7 +81,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           repository: ${{ fromJson(needs.Authorization.outputs.args).repo }}
           ref: ${{ fromJson(needs.Authorization.outputs.args).ref }}
@@ -89,7 +89,7 @@ jobs:
 
       # repo specific steps
       - name: Setup java
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v4
         with:
           distribution: adopt
           java-version: 8
diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 2cb86b2865..267e6395e4 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -1,4 +1,4 @@
-# Copyright (c) 2023, NVIDIA CORPORATION.
+# Copyright (c) 2023-2024, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -26,7 +26,7 @@ jobs:
     - uses: actions/checkout@v4
       with:
         submodules: true
-    - uses: actions/setup-python@v4
+    - uses: actions/setup-python@v5
       with:
         python-version: "3.10"
     - uses: pre-commit/action@v3.0.0
diff --git a/.github/workflows/signoff-check.yml b/.github/workflows/signoff-check.yml
index c2d1d6bf31..4a0eece7d1 100755
--- a/.github/workflows/signoff-check.yml
+++ b/.github/workflows/signoff-check.yml
@@ -1,4 +1,4 @@
-# Copyright (c) 2022, NVIDIA CORPORATION.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -23,7 +23,7 @@ jobs:
   signoff-check:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: sigoff-check job
         uses: ./.github/workflows/signoff-check

From 0bda0dc7feb94de47de9daa07970faf4459f8dda Mon Sep 17 00:00:00 2001
From: Jenkins Automation <70000568+nvauto@users.noreply.github.com>
Date: Tue, 9 Apr 2024 06:03:24 +0800
Subject: [PATCH 129/132] Update submodule cudf to
 e6cfd4503af063d3bba28954ab7ec67dbbb44e71 (#1934)

Signed-off-by: spark-rapids automation <70000568+nvauto@users.noreply.github.com>
---
 thirdparty/cudf                    | 2 +-
 thirdparty/cudf-pins/versions.json | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/thirdparty/cudf b/thirdparty/cudf
index 35f818b3e4..e6cfd4503a 160000
--- a/thirdparty/cudf
+++ b/thirdparty/cudf
@@ -1 +1 @@
-Subproject commit 35f818b3e4bef8e331f083dadc9a4c45e2987a78
+Subproject commit e6cfd4503af063d3bba28954ab7ec67dbbb44e71
diff --git a/thirdparty/cudf-pins/versions.json b/thirdparty/cudf-pins/versions.json
index f8e4379cd4..cf97df89ae 100644
--- a/thirdparty/cudf-pins/versions.json
+++ b/thirdparty/cudf-pins/versions.json
@@ -62,7 +62,7 @@
     {
       "always_download" : true,
       "git_shallow" : false,
-      "git_tag" : "c98eabbad1f60dfe640d03f03a2df58b23f3e167",
+      "git_tag" : "745b1847f56c8f4b0c4e094f93837c2a91e18318",
       "git_url" : "https://github.com/rapidsai/kvikio.git",
       "version" : "24.04"
     },
@@ -110,7 +110,7 @@
     {
       "always_download" : true,
       "git_shallow" : false,
-      "git_tag" : "047df5e87d84834f8f4225898476145741acfa80",
+      "git_tag" : "e38b993f4cb3207745735c51d4f61cdaa735b7ac",
       "git_url" : "https://github.com/rapidsai/jitify.git",
       "version" : "2.0.0"
     },

From a9fbf41b2ad86baffa1e9d1879408395fe3b9a18 Mon Sep 17 00:00:00 2001
From: YanxuanLiu <104543031+YanxuanLiu@users.noreply.github.com>
Date: Tue, 9 Apr 2024 11:09:50 +0800
Subject: [PATCH 130/132] Update blossom-ci.yml (#1937)

* Update blossom-ci.yml

* Update blossom-ci.yml

Signed-off-by: YanxuanLiu <yanxuanl@nvidia.com>

---------

Signed-off-by: YanxuanLiu <yanxuanl@nvidia.com>
---
 .github/workflows/blossom-ci.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/blossom-ci.yml b/.github/workflows/blossom-ci.yml
index 2d09c02be0..ece14b4201 100644
--- a/.github/workflows/blossom-ci.yml
+++ b/.github/workflows/blossom-ci.yml
@@ -81,7 +81,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           repository: ${{ fromJson(needs.Authorization.outputs.args).repo }}
           ref: ${{ fromJson(needs.Authorization.outputs.args).ref }}
@@ -89,7 +89,7 @@ jobs:
 
       # repo specific steps
       - name: Setup java
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v3
         with:
           distribution: adopt
           java-version: 8

From c0003fa8d13560fd88bcdda21b8a6a1956350f8d Mon Sep 17 00:00:00 2001
From: Tim Liu <timl@nvidia.com>
Date: Wed, 10 Apr 2024 07:16:38 +0800
Subject: [PATCH 131/132] Revert cudf submodule change (#1933)

Signed-off-by: Tim Liu <timl@nvidia.com>
---
 ci/Jenkinsfile.premerge | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/ci/Jenkinsfile.premerge b/ci/Jenkinsfile.premerge
index ca62d590a3..a59db1af9a 100644
--- a/ci/Jenkinsfile.premerge
+++ b/ci/Jenkinsfile.premerge
@@ -1,6 +1,6 @@
 #!/usr/local/env groovy
 /*
- * Copyright (c) 2022-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -93,7 +93,7 @@ pipeline {
 
                     def title = githubHelper.getIssue().title
                     if (title ==~ /.*\[skip ci\].*/) {
-                        githubHelper.updateCommitStatus("$BUILD_URL", "Skipped", GitHubCommitState.SUCCESS)
+                        githubHelper.updateCommitStatus("", "Skipped", GitHubCommitState.SUCCESS)
                         currentBuild.result == "SUCCESS"
                         skipped = true
                         return
@@ -122,7 +122,7 @@ pipeline {
 
             steps {
                 script {
-                    githubHelper.updateCommitStatus("$BUILD_URL", "Running", GitHubCommitState.PENDING)
+                    githubHelper.updateCommitStatus("", "Running", GitHubCommitState.PENDING)
                     checkout(
                         changelog: false,
                         poll: true,
@@ -229,7 +229,7 @@ git --no-pager diff --name-only HEAD \$BASE -- ${PREMERGE_DOCKERFILE} || true"""
                 }
 
                 if (currentBuild.currentResult == "SUCCESS") {
-                    githubHelper.updateCommitStatus("$BUILD_URL", "Success", GitHubCommitState.SUCCESS)
+                    githubHelper.updateCommitStatus("", "Success", GitHubCommitState.SUCCESS)
                 } else {
                     // upload log only in case of build failure
                     def guardWords = ["gitlab.*?\\.com", "urm.*?\\.com"]
@@ -237,7 +237,7 @@ git --no-pager diff --name-only HEAD \$BASE -- ${PREMERGE_DOCKERFILE} || true"""
                     guardWords.add("sc-ipp*") // hide cloud info
                     githubHelper.uploadLogs(this, env.JOB_NAME, env.BUILD_NUMBER, null, guardWords)
 
-                    githubHelper.updateCommitStatus("$BUILD_URL", "Fail", GitHubCommitState.FAILURE)
+                    githubHelper.updateCommitStatus("", "Fail", GitHubCommitState.FAILURE)
                 }
 
                 if (TEMP_IMAGE_BUILD) {

From 5d34d471cae9dae3418755e3bff0f15237ae36eb Mon Sep 17 00:00:00 2001
From: jenkins <jenkins@localhost>
Date: Wed, 10 Apr 2024 16:06:39 +0000
Subject: [PATCH 132/132] Change version to 24.04.0

Signed-off-by: jenkins <jenkins@localhost>
---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 8dca17cf3e..8c366a946b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -21,7 +21,7 @@
 
   <groupId>com.nvidia</groupId>
   <artifactId>spark-rapids-jni</artifactId>
-  <version>24.04.0-SNAPSHOT</version>
+  <version>24.04.0</version>
   <packaging>jar</packaging>
   <name>RAPIDS Accelerator JNI for Apache Spark</name>
   <description>