From 1117ca1ce4ed637616a121f4c52306cdaaa26e33 Mon Sep 17 00:00:00 2001 From: Basit Ayantunde Date: Wed, 25 Feb 2026 12:15:19 +0000 Subject: [PATCH 01/12] [FEA] Add JIT cache management functions --- cpp/include/cudf/context.hpp | 15 ++++++++ cpp/src/jit/cache.cpp | 57 +++++++++++++++++++---------- cpp/src/jit/cache.hpp | 25 ++++++++++++- cpp/src/runtime/context.cpp | 6 ++- cpp/src/transform/compute_column.cu | 4 ++ 5 files changed, 86 insertions(+), 21 deletions(-) diff --git a/cpp/include/cudf/context.hpp b/cpp/include/cudf/context.hpp index e9172c91cdbf..4d75b274bf68 100644 --- a/cpp/include/cudf/context.hpp +++ b/cpp/include/cudf/context.hpp @@ -78,4 +78,19 @@ void initialize(init_flags flags = init_flags::INIT_JIT_CACHE); /// teardown and that only one thread calls teardown at a time. void teardown(); +/// @brief Enable or disable the JIT program cache. When disabled, the cache will not be used for +/// storing or retrieving compiled programs, effectively bypassing the cache. When enabled, the +/// cache will be used as normal. This can be used to temporarily disable caching without clearing +/// the existing cache contents, allowing for easy re-enabling of the cache later. +/// @param enable If `true`, the JIT program cache is enabled; if `false`, it is disabled. +void enable_jit_cache(bool enable); + +/// @brief Clear the JIT program cache, removing all cached programs from memory and disk. This is a +/// more expensive operation than simply disabling the cache, as it involves deleting cached files +/// from disk, but it also frees up any memory used by the cached programs. Use +/// `enable_jit_cache(false)` if you want to temporarily disable caching without clearing existing +/// cache contents. +/// @warning For benchmarking or testing purposes, prefer `enable_jit_cache`. +void clear_jit_cache(); + } // namespace CUDF_EXPORT cudf diff --git a/cpp/src/jit/cache.cpp b/cpp/src/jit/cache.cpp index 7d03ed8fdbca..41508468fc34 100644 --- a/cpp/src/jit/cache.cpp +++ b/cpp/src/jit/cache.cpp @@ -3,6 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ +#include "io/utilities/getenv_or.hpp" #include "runtime/context.hpp" #include @@ -95,40 +96,58 @@ std::string get_program_cache_dir() #endif } -std::size_t try_parse_numeric_env_var(char const* const env_name, std::size_t default_val) -{ - auto const value = std::getenv(env_name); - return value != nullptr ? std::stoull(value) : default_val; -} } // namespace jitify2::ProgramCache<>& jit::program_cache::get(jitify2::PreprocessedProgramData const& preprog) { CUDF_FUNC_RANGE(); - std::lock_guard const caches_lock(_caches_mutex); + std::lock_guard caches_lock(_caches_mutex); auto existing_cache = _caches.find(preprog.name()); - if (existing_cache == _caches.end()) { - auto const kernel_limit_proc = - try_parse_numeric_env_var("LIBCUDF_KERNEL_CACHE_LIMIT_PER_PROCESS", 10'000); - auto const kernel_limit_disk = - try_parse_numeric_env_var("LIBCUDF_KERNEL_CACHE_LIMIT_DISK", 100'000); - - // if kernel_limit_disk is zero, jitify will assign it the value of kernel_limit_proc. - // to avoid this, we treat zero as "disable disk caching" by not providing the cache dir. - auto const cache_dir = kernel_limit_disk == 0 ? std::string{} : get_program_cache_dir(); - - auto const res = - _caches.insert({preprog.name(), + if (existing_cache == _caches.end() || _disabled.load(std::memory_order_seq_cst)) { + auto res = + _caches.emplace(preprog.name(), std::make_unique>( - kernel_limit_proc, preprog, nullptr, cache_dir, kernel_limit_disk)}); + _kernel_limit_proc, preprog, nullptr, _cache_dir, _kernel_limit_disk)); existing_cache = res.first; } return *(existing_cache->second); } +void jit::program_cache::clear() +{ + CUDF_FUNC_RANGE(); + std::lock_guard caches_lock(_caches_mutex); + + _caches.clear(); + + // non-atomic + std::filesystem::remove_all(_cache_dir); +} + +void jit::program_cache::enable(bool enable) +{ + _disabled.store(!enable, std::memory_order_seq_cst); +} + +bool jit::program_cache::is_enabled() const { return !_disabled.load(std::memory_order_seq_cst); } + +std::unique_ptr jit::program_cache::create() +{ + auto kernel_limit_proc = getenv_or("LIBCUDF_KERNEL_CACHE_LIMIT_PER_PROCESS", 10'000); + auto kernel_limit_disk = getenv_or("LIBCUDF_KERNEL_CACHE_LIMIT_DISK", 100'000); + auto disabled = get_bool_env_or("LIBCUDF_KERNEL_CACHE_DISABLED", false); + + // if kernel_limit_disk is zero, jitify will assign it the value of kernel_limit_proc. + // to avoid this, we treat zero as "disable disk caching" by not providing the cache dir. + auto cache_dir = kernel_limit_disk == 0 ? std::string{} : get_program_cache_dir(); + + return std::make_unique( + kernel_limit_proc, kernel_limit_disk, cache_dir, disabled); +} + jitify2::ProgramCache<>& jit::get_program_cache(jitify2::PreprocessedProgramData const& preprog) { return cudf::get_context().program_cache().get(preprog); diff --git a/cpp/src/jit/cache.hpp b/cpp/src/jit/cache.hpp index c130b953fc9f..71264b053eda 100644 --- a/cpp/src/jit/cache.hpp +++ b/cpp/src/jit/cache.hpp @@ -11,6 +11,7 @@ #include +#include #include #include #include @@ -21,9 +22,23 @@ namespace jit { class program_cache { std::mutex _caches_mutex; std::unordered_map>> _caches; + int32_t _kernel_limit_proc; + int32_t _kernel_limit_disk; + std::filesystem::path _cache_dir; + std::atomic _disabled; public: - program_cache() = default; + program_cache(int32_t kernel_limit_proc, + int32_t kernel_limit_disk, + std::filesystem::path cache_dir, + bool disabled) + : _kernel_limit_proc(kernel_limit_proc), + _kernel_limit_disk(kernel_limit_disk), + _cache_dir(std::move(cache_dir)), + _disabled(disabled) + { + } + program_cache(program_cache const&) = delete; program_cache(program_cache&&) = delete; program_cache& operator=(program_cache const&) = delete; @@ -31,6 +46,14 @@ class program_cache { ~program_cache() = default; jitify2::ProgramCache<>& get(jitify2::PreprocessedProgramData const& preprog); + + void clear(); + + void enable(bool enable); + + bool is_enabled() const; + + static std::unique_ptr create(); }; jitify2::ProgramCache<>& get_program_cache(jitify2::PreprocessedProgramData const& preprog); diff --git a/cpp/src/runtime/context.cpp b/cpp/src/runtime/context.cpp index 561840b9a587..6e78060e8792 100644 --- a/cpp/src/runtime/context.cpp +++ b/cpp/src/runtime/context.cpp @@ -27,7 +27,7 @@ void context::ensure_nvcomp_loaded() { io::detail::nvcomp::load_nvcomp_library() void context::ensure_jit_cache_initialized() { std::call_once(_program_cache_init_flag, - [&]() { _program_cache = std::make_unique(); }); + [&]() { _program_cache = jit::program_cache::create(); }); } jit::program_cache& context::program_cache() @@ -85,6 +85,10 @@ void teardown() }); } +void enable_jit_cache(bool enable) { get_context().program_cache().enable(enable); } + +void clear_jit_cache() { get_context().program_cache().clear(); } + context& get_context() { cudf::initialize(); diff --git a/cpp/src/transform/compute_column.cu b/cpp/src/transform/compute_column.cu index b512aafeb83d..f73872dc1d83 100644 --- a/cpp/src/transform/compute_column.cu +++ b/cpp/src/transform/compute_column.cu @@ -22,6 +22,8 @@ #include #include +#include + #include namespace cudf { @@ -31,6 +33,8 @@ std::unique_ptr compute_column(table_view const& table, rmm::cuda_stream_view stream, rmm::device_async_resource_ref mr) { + if (get_context().use_jit()) { return compute_column_jit(table, expr, stream, mr); } + // If evaluating the expression may produce null outputs we create a nullable // output column and follow the null-supporting expression evaluation code // path. From c4f9934830705050053053f936e01866391388e9 Mon Sep 17 00:00:00 2001 From: Basit Ayantunde Date: Wed, 25 Feb 2026 12:17:10 +0000 Subject: [PATCH 02/12] [DOC] Update copyright year to 2026 in source files --- cpp/src/jit/cache.cpp | 2 +- cpp/src/jit/cache.hpp | 2 +- cpp/src/transform/compute_column.cu | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/cpp/src/jit/cache.cpp b/cpp/src/jit/cache.cpp index 41508468fc34..5100836ebe1e 100644 --- a/cpp/src/jit/cache.cpp +++ b/cpp/src/jit/cache.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2019-2025, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION. * SPDX-License-Identifier: Apache-2.0 */ diff --git a/cpp/src/jit/cache.hpp b/cpp/src/jit/cache.hpp index 71264b053eda..4a36393d9658 100644 --- a/cpp/src/jit/cache.hpp +++ b/cpp/src/jit/cache.hpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2019-2025, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION. * SPDX-License-Identifier: Apache-2.0 */ diff --git a/cpp/src/transform/compute_column.cu b/cpp/src/transform/compute_column.cu index f73872dc1d83..520995e24da0 100644 --- a/cpp/src/transform/compute_column.cu +++ b/cpp/src/transform/compute_column.cu @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2020-2025, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION. * SPDX-License-Identifier: Apache-2.0 */ From 82ddb4e5bf5442207532e05c8c2fe3dbeb980be1 Mon Sep 17 00:00:00 2001 From: Basit Ayantunde Date: Wed, 25 Feb 2026 12:44:20 +0000 Subject: [PATCH 03/12] [FEA] Add option to clear JIT cache on creation based on environment variable --- cpp/src/jit/cache.cpp | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/cpp/src/jit/cache.cpp b/cpp/src/jit/cache.cpp index 5100836ebe1e..cc5a2c8491e3 100644 --- a/cpp/src/jit/cache.cpp +++ b/cpp/src/jit/cache.cpp @@ -139,13 +139,18 @@ std::unique_ptr jit::program_cache::create() auto kernel_limit_proc = getenv_or("LIBCUDF_KERNEL_CACHE_LIMIT_PER_PROCESS", 10'000); auto kernel_limit_disk = getenv_or("LIBCUDF_KERNEL_CACHE_LIMIT_DISK", 100'000); auto disabled = get_bool_env_or("LIBCUDF_KERNEL_CACHE_DISABLED", false); + auto clear_cache = get_bool_env_or("LIBCUDF_KERNEL_CACHE_CLEAR", false); // if kernel_limit_disk is zero, jitify will assign it the value of kernel_limit_proc. // to avoid this, we treat zero as "disable disk caching" by not providing the cache dir. auto cache_dir = kernel_limit_disk == 0 ? std::string{} : get_program_cache_dir(); - return std::make_unique( - kernel_limit_proc, kernel_limit_disk, cache_dir, disabled); + auto cache = + std::make_unique(kernel_limit_proc, kernel_limit_disk, cache_dir, disabled); + + if (clear_cache) { cache->clear(); } + + return cache; } jitify2::ProgramCache<>& jit::get_program_cache(jitify2::PreprocessedProgramData const& preprog) From 40d8273271e2aea78f0597581496d91667508c34 Mon Sep 17 00:00:00 2001 From: Basit Ayantunde Date: Wed, 25 Feb 2026 14:01:20 +0000 Subject: [PATCH 04/12] Update cpp/include/cudf/context.hpp Co-authored-by: David Wendt <45795991+davidwendt@users.noreply.github.com> --- cpp/include/cudf/context.hpp | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/cpp/include/cudf/context.hpp b/cpp/include/cudf/context.hpp index 4d75b274bf68..6869ad7c0ffe 100644 --- a/cpp/include/cudf/context.hpp +++ b/cpp/include/cudf/context.hpp @@ -78,11 +78,16 @@ void initialize(init_flags flags = init_flags::INIT_JIT_CACHE); /// teardown and that only one thread calls teardown at a time. void teardown(); -/// @brief Enable or disable the JIT program cache. When disabled, the cache will not be used for -/// storing or retrieving compiled programs, effectively bypassing the cache. When enabled, the -/// cache will be used as normal. This can be used to temporarily disable caching without clearing -/// the existing cache contents, allowing for easy re-enabling of the cache later. -/// @param enable If `true`, the JIT program cache is enabled; if `false`, it is disabled. +/** + * @brief Enable or disable the JIT program cache + * + * When disabled, the cache will not be used for + * storing or retrieving compiled programs, effectively bypassing the cache. When enabled, the + * cache will be used as normal. This can be used to temporarily disable caching without clearing + * the existing cache contents, allowing for easy re-enabling of the cache later. + * + * @param enable If `true`, the JIT program cache is enabled; if `false`, it is disabled. + */ void enable_jit_cache(bool enable); /// @brief Clear the JIT program cache, removing all cached programs from memory and disk. This is a From 40c84da7bb087fd0c04955896036d9e83374866a Mon Sep 17 00:00:00 2001 From: Basit Ayantunde Date: Wed, 25 Feb 2026 21:47:28 +0000 Subject: [PATCH 05/12] DOC: Improve documentation formatting for enable_jit_cache function --- cpp/include/cudf/context.hpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/cpp/include/cudf/context.hpp b/cpp/include/cudf/context.hpp index 6869ad7c0ffe..17e0c36cdf78 100644 --- a/cpp/include/cudf/context.hpp +++ b/cpp/include/cudf/context.hpp @@ -79,15 +79,15 @@ void initialize(init_flags flags = init_flags::INIT_JIT_CACHE); void teardown(); /** - * @brief Enable or disable the JIT program cache - * - * When disabled, the cache will not be used for - * storing or retrieving compiled programs, effectively bypassing the cache. When enabled, the - * cache will be used as normal. This can be used to temporarily disable caching without clearing - * the existing cache contents, allowing for easy re-enabling of the cache later. - * - * @param enable If `true`, the JIT program cache is enabled; if `false`, it is disabled. - */ + * @brief Enable or disable the JIT program cache + * + * When disabled, the cache will not be used for + * storing or retrieving compiled programs, effectively bypassing the cache. When enabled, the + * cache will be used as normal. This can be used to temporarily disable caching without clearing + * the existing cache contents, allowing for easy re-enabling of the cache later. + * + * @param enable If `true`, the JIT program cache is enabled; if `false`, it is disabled. + */ void enable_jit_cache(bool enable); /// @brief Clear the JIT program cache, removing all cached programs from memory and disk. This is a From a356c71c38fb1d68b96b9a592d77cb564231f449 Mon Sep 17 00:00:00 2001 From: Basit Ayantunde Date: Wed, 25 Feb 2026 22:01:39 +0000 Subject: [PATCH 06/12] DOC: Improve documentation formatting for clear_jit_cache function --- cpp/include/cudf/context.hpp | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/cpp/include/cudf/context.hpp b/cpp/include/cudf/context.hpp index 17e0c36cdf78..7eb6f5d273fc 100644 --- a/cpp/include/cudf/context.hpp +++ b/cpp/include/cudf/context.hpp @@ -90,12 +90,16 @@ void teardown(); */ void enable_jit_cache(bool enable); -/// @brief Clear the JIT program cache, removing all cached programs from memory and disk. This is a -/// more expensive operation than simply disabling the cache, as it involves deleting cached files -/// from disk, but it also frees up any memory used by the cached programs. Use -/// `enable_jit_cache(false)` if you want to temporarily disable caching without clearing existing -/// cache contents. -/// @warning For benchmarking or testing purposes, prefer `enable_jit_cache`. +/** + * @brief Clear the JIT program cache, removing all cached programs from memory and disk. + * + * This is a more expensive operation than simply disabling the cache, as it involves deleting + * cached files from disk, but it also frees up any memory used by the cached programs. Use + * `enable_jit_cache(false)` if you want to temporarily disable caching without clearing existing + * cache contents. + * + * @warning For benchmarking or testing purposes, prefer `enable_jit_cache`. + */ void clear_jit_cache(); } // namespace CUDF_EXPORT cudf From 6af56c4b4cce4d9ec403cdae41c1c645bbd64f19 Mon Sep 17 00:00:00 2001 From: Basit Ayantunde Date: Mon, 2 Mar 2026 13:44:30 +0000 Subject: [PATCH 07/12] formatting --- cpp/src/transform/transform.cu | 1 + 1 file changed, 1 insertion(+) diff --git a/cpp/src/transform/transform.cu b/cpp/src/transform/transform.cu index c909b94efe32..55ab90913bdc 100644 --- a/cpp/src/transform/transform.cu +++ b/cpp/src/transform/transform.cu @@ -148,6 +148,7 @@ auto to_device_input_arg(InputsView inputs, rmm::device_async_resource_ref mr) { std::vector columns; + for (auto const& input : inputs) { columns.emplace_back(std::visit([](auto const& col) { return to_column_view(col); }, input)); } From db33a9b9a1e59e43e5fa00b55e5f31045f42e048 Mon Sep 17 00:00:00 2001 From: Basit Ayantunde Date: Wed, 11 Mar 2026 01:43:24 +0000 Subject: [PATCH 08/12] Update cpp/src/jit/cache.hpp Co-authored-by: Yunsong Wang <12716979+PointKernel@users.noreply.github.com> --- cpp/src/jit/cache.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cpp/src/jit/cache.hpp b/cpp/src/jit/cache.hpp index 4a36393d9658..a8c9af09a473 100644 --- a/cpp/src/jit/cache.hpp +++ b/cpp/src/jit/cache.hpp @@ -32,10 +32,10 @@ class program_cache { int32_t kernel_limit_disk, std::filesystem::path cache_dir, bool disabled) - : _kernel_limit_proc(kernel_limit_proc), - _kernel_limit_disk(kernel_limit_disk), - _cache_dir(std::move(cache_dir)), - _disabled(disabled) + : _kernel_limit_proc {kernel_limit_proc}, + _kernel_limit_disk{kernel_limit_disk}, + _cache_dir{std::move(cache_dir)}, + _disabled{disabled} { } From 08610185ae9aace2acc783d562fc1254c4e662ff Mon Sep 17 00:00:00 2001 From: Basit Ayantunde Date: Wed, 11 Mar 2026 01:45:24 +0000 Subject: [PATCH 09/12] Update cpp/src/jit/cache.cpp Co-authored-by: Yunsong Wang <12716979+PointKernel@users.noreply.github.com> --- cpp/src/jit/cache.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cpp/src/jit/cache.cpp b/cpp/src/jit/cache.cpp index cc5a2c8491e3..b988296b0b7e 100644 --- a/cpp/src/jit/cache.cpp +++ b/cpp/src/jit/cache.cpp @@ -136,10 +136,10 @@ bool jit::program_cache::is_enabled() const { return !_disabled.load(std::memory std::unique_ptr jit::program_cache::create() { - auto kernel_limit_proc = getenv_or("LIBCUDF_KERNEL_CACHE_LIMIT_PER_PROCESS", 10'000); - auto kernel_limit_disk = getenv_or("LIBCUDF_KERNEL_CACHE_LIMIT_DISK", 100'000); - auto disabled = get_bool_env_or("LIBCUDF_KERNEL_CACHE_DISABLED", false); - auto clear_cache = get_bool_env_or("LIBCUDF_KERNEL_CACHE_CLEAR", false); + auto const kernel_limit_proc = getenv_or("LIBCUDF_KERNEL_CACHE_LIMIT_PER_PROCESS", 10'000); + auto const kernel_limit_disk = getenv_or("LIBCUDF_KERNEL_CACHE_LIMIT_DISK", 100'000); + auto const disabled = get_bool_env_or("LIBCUDF_KERNEL_CACHE_DISABLED", false); + auto const clear_cache = get_bool_env_or("LIBCUDF_KERNEL_CACHE_CLEAR", false); // if kernel_limit_disk is zero, jitify will assign it the value of kernel_limit_proc. // to avoid this, we treat zero as "disable disk caching" by not providing the cache dir. From 6a0d7382ba476d7dc20d44c0a1cc7c25643635d3 Mon Sep 17 00:00:00 2001 From: Basit Ayantunde Date: Wed, 11 Mar 2026 01:45:36 +0000 Subject: [PATCH 10/12] Update cpp/src/transform/compute_column.cu Co-authored-by: Nghia Truong <7416935+ttnghia@users.noreply.github.com> --- cpp/src/transform/compute_column.cu | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cpp/src/transform/compute_column.cu b/cpp/src/transform/compute_column.cu index 520995e24da0..2fd783dce8a9 100644 --- a/cpp/src/transform/compute_column.cu +++ b/cpp/src/transform/compute_column.cu @@ -22,7 +22,7 @@ #include #include -#include +#include "runtime/context.hpp" #include From c7b7a1bc472ea20126ff3fb3faaec7b0e83f613c Mon Sep 17 00:00:00 2001 From: Basit Ayantunde Date: Wed, 11 Mar 2026 01:45:44 +0000 Subject: [PATCH 11/12] Update cpp/src/jit/cache.hpp Co-authored-by: Nghia Truong <7416935+ttnghia@users.noreply.github.com> --- cpp/src/jit/cache.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/cpp/src/jit/cache.hpp b/cpp/src/jit/cache.hpp index a8c9af09a473..543b75f97201 100644 --- a/cpp/src/jit/cache.hpp +++ b/cpp/src/jit/cache.hpp @@ -12,6 +12,7 @@ #include #include +#include #include #include #include From 768eed036b825648b021938cea8446cea8c284ec Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 11 Mar 2026 13:01:16 +0000 Subject: [PATCH 12/12] [pre-commit.ci] auto code formatting --- cpp/src/jit/cache.hpp | 4 ++-- cpp/src/transform/compute_column.cu | 3 +-- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/cpp/src/jit/cache.hpp b/cpp/src/jit/cache.hpp index 543b75f97201..0e6738fed176 100644 --- a/cpp/src/jit/cache.hpp +++ b/cpp/src/jit/cache.hpp @@ -11,8 +11,8 @@ #include -#include #include +#include #include #include #include @@ -33,7 +33,7 @@ class program_cache { int32_t kernel_limit_disk, std::filesystem::path cache_dir, bool disabled) - : _kernel_limit_proc {kernel_limit_proc}, + : _kernel_limit_proc{kernel_limit_proc}, _kernel_limit_disk{kernel_limit_disk}, _cache_dir{std::move(cache_dir)}, _disabled{disabled} diff --git a/cpp/src/transform/compute_column.cu b/cpp/src/transform/compute_column.cu index 2fd783dce8a9..1b1e02ccdb6c 100644 --- a/cpp/src/transform/compute_column.cu +++ b/cpp/src/transform/compute_column.cu @@ -4,6 +4,7 @@ */ #include "compute_column_kernel.hpp" +#include "runtime/context.hpp" #include #include @@ -22,8 +23,6 @@ #include #include -#include "runtime/context.hpp" - #include namespace cudf {