Ensure minimal set of cpp/ functions used by tests are marked public

cpp/src/io/comp/gpuinflate.hpp

@@ -17,6 +17,7 @@
 #pragma once
 
 #include <cudf/io/types.hpp>
+#include <cudf/utilities/export.hpp>
 #include <cudf/utilities/span.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
@@ -73,6 +74,7 @@ constexpr std::size_t BUFFER_PADDING_MULTIPLE{8};
  * @param[in] parse_hdr Whether or not to parse GZIP header
  * @param[in] stream CUDA stream to use
  */
+CUDF_EXPORT
 void gpuinflate(device_span<device_span<uint8_t const> const> inputs,
                 device_span<device_span<uint8_t> const> outputs,
                 device_span<compression_result> results,
@@ -101,6 +103,7 @@ void gpu_copy_uncompressed_blocks(device_span<device_span<uint8_t const> const>
  * @param[out] results List of output status structures
  * @param[in] stream CUDA stream to use
  */
+CUDF_EXPORT
 void gpu_unsnap(device_span<device_span<uint8_t const> const> inputs,
                 device_span<device_span<uint8_t> const> outputs,
                 device_span<compression_result> results,
@@ -113,6 +116,7 @@ void gpu_unsnap(device_span<device_span<uint8_t const> const> inputs,
  *
  * @return The size in bytes of required temporary memory
  */
+CUDF_EXPORT
 size_t get_gpu_debrotli_scratch_size(int max_num_inputs = 0);
 
 /**
@@ -128,6 +132,7 @@ size_t get_gpu_debrotli_scratch_size(int max_num_inputs = 0);
  * @param[in] scratch_size Size in bytes of the temporary memory
  * @param[in] stream CUDA stream to use
  */
+CUDF_EXPORT
 void gpu_debrotli(device_span<device_span<uint8_t const> const> inputs,
                   device_span<device_span<uint8_t> const> outputs,
                   device_span<compression_result> results,

cpp/src/io/json/nested_json.hpp

@@ -21,17 +21,20 @@
 #include <cudf/types.hpp>
 #include <cudf/utilities/bit.hpp>
 #include <cudf/utilities/error.hpp>
+#include <cudf/utilities/export.hpp>
 
 #include <rmm/resource_ref.hpp>
 
 #include <map>
 #include <vector>
 
 // Forward declaration of parse_options from parsing_utils.cuh
-namespace cudf::io {
+namespace cudf {
+namespace io {
+
 struct parse_options;
-}
-namespace cudf::io::json {
+
+namespace json {
 
 /**
  * @brief Struct that encapsulate all information of a columnar tree representation.
@@ -201,6 +204,7 @@ namespace detail {
  * @param[in] delimiter Specifies the delimiter to use as separator for JSON lines input
  * @param[in] stream The cuda stream to dispatch GPU kernels to
  */
+CUDF_EXPORT
 void get_stack_context(device_span<SymbolT const> json_in,
                        SymbolT* d_top_of_stack,
                        stack_behavior_t stack_behavior,
@@ -216,6 +220,7 @@ void get_stack_context(device_span<SymbolT const> json_in,
  * @param stream The cuda stream to dispatch GPU kernels to
  * @return Returns the post-processed token stream
  */
+CUDF_EXPORT
 std::pair<rmm::device_uvector<PdaTokenT>, rmm::device_uvector<SymbolOffsetT>> process_token_stream(
   device_span<PdaTokenT const> tokens,
   device_span<SymbolOffsetT const> token_indices,
@@ -232,6 +237,7 @@ std::pair<rmm::device_uvector<PdaTokenT>, rmm::device_uvector<SymbolOffsetT>> pr
  * @return A tree representation of the input JSON string as vectors of node type, parent index,
  * level, begin index, and end index in the input JSON string
  */
+CUDF_EXPORT
 tree_meta_t get_tree_representation(device_span<PdaTokenT const> tokens,
                                     device_span<SymbolOffsetT const> token_indices,
                                     bool is_strict_nested_boundaries,
@@ -251,6 +257,7 @@ tree_meta_t get_tree_representation(device_span<PdaTokenT const> tokens,
  * @param mr Optional, resource with which to allocate
  * @return A tuple of the output column indices and the row offsets within each column for each node
  */
+CUDF_EXPORT
 std::tuple<rmm::device_uvector<NodeIndexT>, rmm::device_uvector<size_type>>
 records_orient_tree_traversal(device_span<SymbolT const> d_input,
                               tree_meta_t const& d_tree,
@@ -315,6 +322,7 @@ cudf::io::parse_options parsing_options(cudf::io::json_reader_options const& opt
  * @param mr Optional, resource with which to allocate
  * @return The data parsed from the given JSON input
  */
+CUDF_EXPORT
 table_with_metadata device_parse_nested_json(device_span<SymbolT const> input,
                                              cudf::io::json_reader_options const& options,
                                              rmm::cuda_stream_view stream,
@@ -348,4 +356,6 @@ struct path_from_tree {
 
 }  // namespace detail
 
-}  // namespace cudf::io::json
+}  // namespace json
+}  // namespace io
+}  // namespace cudf

cpp/src/io/json/read_json.hpp

@@ -19,6 +19,7 @@
 #include <cudf/io/datasource.hpp>
 #include <cudf/io/json.hpp>
 #include <cudf/types.hpp>
+#include <cudf/utilities/export.hpp>
 #include <cudf/utilities/span.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
@@ -27,7 +28,8 @@
 
 #include <memory>
 
-namespace cudf::io::json::detail {
+namespace cudf {
+namespace io::json::detail {
 
 table_with_metadata read_json(host_span<std::unique_ptr<datasource>> sources,
                               json_reader_options const& reader_opts,
@@ -38,9 +40,11 @@ size_type find_first_delimiter(device_span<char const> d_data,
                                char const delimiter,
                                rmm::cuda_stream_view stream);
 
+CUDF_EXPORT
 size_type find_first_delimiter_in_chunk(host_span<std::unique_ptr<cudf::io::datasource>> sources,
                                         json_reader_options const& reader_opts,
                                         char const delimiter,
                                         rmm::cuda_stream_view stream);
 
-}  // namespace cudf::io::json::detail
+}  // namespace io::json::detail
+}  // namespace cudf

cpp/src/io/parquet/compact_protocol_reader.hpp

@@ -18,14 +18,17 @@
 
 #include "parquet.hpp"
 
+#include <cudf/utilities/export.hpp>
+
 #include <algorithm>
 #include <cstddef>
 #include <optional>
 #include <string>
 #include <utility>
 #include <vector>
 
-namespace cudf::io::parquet::detail {
+namespace CUDF_EXPORT cudf {
+namespace io::parquet::detail {
 
 /**
  * @brief Class for parsing Parquet's Thrift Compact Protocol encoded metadata
@@ -149,4 +152,5 @@ class CompactProtocolReader {
   friend class parquet_field_struct_blob;
 };
 
-}  // namespace cudf::io::parquet::detail
+}  // namespace io::parquet::detail
+}  // namespace cudf

cpp/src/io/utilities/base64_utilities.hpp

@@ -61,10 +61,13 @@
 // altered: applying clang-format for libcudf on this file.
 
 // altered: include required headers
+#include <cudf/utilities/export.hpp>
+
 #include <string>
 
 // altered: use cudf namespaces
-namespace cudf::io::detail {
+namespace CUDF_EXPORT cudf {
+namespace io::detail {
 
 /**
  * @brief Encodes input string to base64 and returns it
@@ -84,4 +87,5 @@ std::string base64_encode(std::string_view string_to_encode);
  */
 std::string base64_decode(std::string_view encoded_string);
 
-}  // namespace cudf::io::detail
+}  // namespace io::detail
+}

cpp/src/io/utilities/file_io_utilities.hpp

@@ -26,6 +26,7 @@
 
 #include <cudf/io/datasource.hpp>
 #include <cudf/utilities/error.hpp>
+#include <cudf/utilities/export.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
 
@@ -212,7 +213,7 @@ std::unique_ptr<cufile_output_impl> make_cufile_output(std::string const& filepa
 /**
  * @brief Byte range to be read/written in a single operation.
  */
-struct file_io_slice {
+CUDF_EXPORT struct file_io_slice {
   size_t offset;
   size_t size;
 };
@@ -222,7 +223,7 @@ struct file_io_slice {
  *
  * If `max_slice_size` is below 1024, 1024 will be used instead to prevent potential misuse.
  */
-std::vector<file_io_slice> make_file_io_slices(size_t size, size_t max_slice_size);
+CUDF_EXPORT std::vector<file_io_slice> make_file_io_slices(size_t size, size_t max_slice_size);
 
 }  // namespace detail
 }  // namespace io

cpp/src/io/utilities/row_selection.hpp

@@ -21,7 +21,8 @@
 #include <optional>
 #include <utility>
 
-namespace cudf::io::detail {
+namespace CUDF_EXPORT cudf {
+namespace io::detail {
 
 /**
  * @brief Adjusts the input skip_rows and num_rows options to the actual number of rows to
@@ -38,4 +39,5 @@ std::pair<int64_t, int64_t> skip_rows_num_rows_from_options(int64_t skip_rows,
                                                             std::optional<int64_t> const& num_rows,
                                                             int64_t num_source_rows);
 
-}  // namespace cudf::io::detail
+}  // namespace io::detail
+}  // namespace cudf

cpp/src/io/utilities/string_parsing.hpp

@@ -18,6 +18,7 @@
 #include "io/utilities/parsing_utils.cuh"
 
 #include <cudf/types.hpp>
+#include <cudf/utilities/export.hpp>
 #include <cudf/utilities/span.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
@@ -43,7 +44,7 @@ namespace detail {
  * @param stream CUDA stream used for device memory operations and kernel launches
  * @return The inferred data type
  */
-cudf::data_type infer_data_type(
+CUDF_EXPORT cudf::data_type infer_data_type(
   cudf::io::json_inference_options_view const& options,
   device_span<char const> data,
   thrust::zip_iterator<thrust::tuple<size_type const*, size_type const*>> offset_length_begin,
@@ -66,7 +67,7 @@ namespace json::detail {
  * @param mr The resource to be used for device memory allocation
  * @return The column that contains the parsed data
  */
-std::unique_ptr<column> parse_data(
+CUDF_EXPORT std::unique_ptr<column> parse_data(
   char const* data,
   thrust::zip_iterator<thrust::tuple<size_type const*, size_type const*>> offset_length_begin,
   size_type col_size,

cpp/src/io/utilities/trie.cuh

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2018-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,6 +21,7 @@
 
 #pragma once
 
+#include <cudf/utilities/export.hpp>
 #include <cudf/utilities/span.hpp>
 
 #include <optional>
@@ -67,7 +68,7 @@ inline trie_view make_trie_view(optional_trie const& t)
  *
  * @return A host vector of nodes representing the serialized trie
  */
-trie create_serialized_trie(std::vector<std::string> const& keys, rmm::cuda_stream_view stream);
+CUDF_EXPORT trie create_serialized_trie(std::vector<std::string> const& keys, rmm::cuda_stream_view stream);
 
 /*
  * @brief Searches for a string in a serialized trie.

cpp/src/jit/parser.hpp

@@ -16,12 +16,14 @@
 
 #pragma once
 
+#include <cudf/utilities/export.hpp>
+
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
-namespace cudf {
+namespace CUDF_EXPORT cudf {
 namespace jit {
 /**
  * @brief Parse and transform a piece of PTX code that contains the implementation