column_utilities.hpp

/*
 * Copyright (c) 2019-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/column/column.hpp>
#include <cudf/column/column_view.hpp>
#include <cudf/detail/utilities/vector_factories.hpp>
#include <cudf/null_mask.hpp>
#include <cudf/strings/strings_column_view.hpp>
#include <cudf/types.hpp>
#include <cudf/utilities/default_stream.hpp>
#include <cudf/utilities/error.hpp>
#include <cudf/utilities/export.hpp>
 
#include <thrust/host_vector.h>
#include <thrust/iterator/transform_iterator.h>
 
namespace CUDF_EXPORT cudf {
namespace test {
 
enum class debug_output_level {
  FIRST_ERROR = 0,  // print first error only
  ALL_ERRORS,       // print all errors
  QUIET             // no debug output
};
 
constexpr size_type default_ulp = 4;
 
namespace detail {
 
bool expect_column_properties_equal(cudf::column_view const& lhs,
                                    cudf::column_view const& rhs,
                                    debug_output_level verbosity = debug_output_level::FIRST_ERROR);
 
bool expect_column_properties_equivalent(
  cudf::column_view const& lhs,
  cudf::column_view const& rhs,
  debug_output_level verbosity = debug_output_level::FIRST_ERROR);
 
bool expect_columns_equal(cudf::column_view const& lhs,
                          cudf::column_view const& rhs,
                          debug_output_level verbosity = debug_output_level::FIRST_ERROR);
 
bool expect_columns_equivalent(cudf::column_view const& lhs,
                               cudf::column_view const& rhs,
                               debug_output_level verbosity = debug_output_level::FIRST_ERROR,
                               size_type fp_ulps            = cudf::test::default_ulp);
 
void expect_equal_buffers(void const* lhs, void const* rhs, std::size_t size_bytes);
 
}  // namespace detail
 
void expect_column_empty(cudf::column_view const& col);
 
std::vector<bitmask_type> bitmask_to_host(cudf::column_view const& c);
 
bool validate_host_masks(std::vector<bitmask_type> const& expected_mask,
                         std::vector<bitmask_type> const& got_mask_begin,
                         size_type number_of_elements);
 
template <typename T, std::enable_if_t<not cudf::is_fixed_point<T>()>* = nullptr>
std::pair<thrust::host_vector<T>, std::vector<bitmask_type>> to_host(column_view c)
{
  auto col_span  = cudf::device_span<T const>(c.data<T>(), c.size());
  auto host_data = cudf::detail::make_host_vector_sync(col_span, cudf::get_default_stream());
  return {std::move(host_data), bitmask_to_host(c)};
}
 
// This signature is identical to the above overload apart from SFINAE so
// doxygen sees it as a duplicate.
 
template <typename T, std::enable_if_t<cudf::is_fixed_point<T>()>* = nullptr>
CUDF_EXPORT std::pair<thrust::host_vector<T>, std::vector<bitmask_type>> to_host(column_view c);
 
template <>
CUDF_EXPORT std::pair<thrust::host_vector<std::string>, std::vector<bitmask_type>> to_host(
  column_view c);
 
struct large_strings_enabler {
  large_strings_enabler(bool default_enable = true);
  ~large_strings_enabler();
 
  void enable();
 
  void disable();
};
 
}  // namespace test
}  // namespace CUDF_EXPORT cudf
 
// Macros for showing line of failure.
#define CUDF_TEST_EXPECT_COLUMN_PROPERTIES_EQUAL(lhs, rhs)        \
  do {                                                            \
    SCOPED_TRACE(" <--  line of failure\n");                      \
    cudf::test::detail::expect_column_properties_equal(lhs, rhs); \
  } while (0)
 
#define CUDF_TEST_EXPECT_COLUMN_PROPERTIES_EQUIVALENT(lhs, rhs)        \
  do {                                                                 \
    SCOPED_TRACE(" <--  line of failure\n");                           \
    cudf::test::detail::expect_column_properties_equivalent(lhs, rhs); \
  } while (0)
 
#define CUDF_TEST_EXPECT_COLUMNS_EQUAL(lhs, rhs...)     \
  do {                                                  \
    SCOPED_TRACE(" <--  line of failure\n");            \
    cudf::test::detail::expect_columns_equal(lhs, rhs); \
  } while (0)
 
#define CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(lhs, rhs...)     \
  do {                                                       \
    SCOPED_TRACE(" <--  line of failure\n");                 \
    cudf::test::detail::expect_columns_equivalent(lhs, rhs); \
  } while (0)
 
#define CUDF_TEST_EXPECT_EQUAL_BUFFERS(lhs, rhs, size_bytes)        \
  do {                                                              \
    SCOPED_TRACE(" <--  line of failure\n");                        \
    cudf::test::detail::expect_equal_buffers(lhs, rhs, size_bytes); \
  } while (0)
 
#define CUDF_TEST_ENABLE_LARGE_STRINGS() cudf::test::large_strings_enabler ls___