types.hpp

转到此文件的文档。

/*
 * 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.
 * You may obtain a copy of the License at
 *
 * https://apache.ac.cn/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

#ifdef __CUDACC__
#define CUDF_HOST_DEVICE __host__ __device__
#define CUDF_KERNEL __global__ static
#else
#define CUDF_HOST_DEVICE
#define CUDF_KERNEL static
#endif

#include <cudf/utilities/export.hpp>

#include <cassert>
#include <cstddef>
#include <cstdint>
#include <iterator>

// Forward declarations
namespace rmm {
class device_buffer;

} // namespace rmm

namespace CUDF_EXPORT cudf {
// Forward declaration
class column;
class column_view;
class mutable_column_view;
class string_view;
class list_view;
class struct_view;
class scalar;

// clang-format off
class list_scalar;
class struct_scalar;
class string_scalar;
template <typename T> class numeric_scalar;
template <typename T> class fixed_point_scalar;
template <typename T> class timestamp_scalar;
template <typename T> class duration_scalar;

class string_scalar_device_view;
template <typename T> class numeric_scalar_device_view;
template <typename T> class fixed_point_scalar_device_view;
template <typename T> class timestamp_scalar_device_view;
template <typename T> class duration_scalar_device_view;
// clang-format on

class table;
class table_view;
class mutable_table_view;

using size_type = int32_t;
using bitmask_type = uint32_t;
using valid_type = uint8_t;
using thread_index_type = int64_t;
using char_utf8 = uint32_t;

template <typename T>
size_type distance(T f, T l)
{
 return static_cast<size_type>(std::distance(f, l));
}

enum class order : bool {
 ASCENDING,
 DESCENDING
};

enum class null_policy : bool {
 EXCLUDE,
 INCLUDE
};

enum class nan_policy : bool {
 NAN_IS_NULL,
 NAN_IS_VALID
};

enum class nan_equality /*unspecified*/ {
 ALL_EQUAL,
 UNEQUAL
};

enum class null_equality : bool {
 EQUAL,
 UNEQUAL
};

enum class null_order : bool {
 AFTER,
 BEFORE
};

enum class sorted : bool { NO, YES };

struct order_info {
 sorted is_sorted;
 order ordering;
 null_order null_ordering;
};

enum class mask_state : int32_t {
 UNALLOCATED,
 UNINITIALIZED,
 ALL_VALID,
 ALL_NULL
};

enum class interpolation : int32_t {
 LINEAR,
 LOWER,
 HIGHER,
 MIDPOINT,
 NEAREST
};

enum class type_id : int32_t {
 EMPTY,
 INT8,
 INT16,
 INT32,
 INT64,
 UINT8,
 UINT16,
 UINT32,
 UINT64,
 FLOAT32,
 FLOAT64,
 BOOL8,
 TIMESTAMP_DAYS,
 TIMESTAMP_SECONDS,
 TIMESTAMP_MILLISECONDS,
 TIMESTAMP_MICROSECONDS,
 TIMESTAMP_NANOSECONDS,
 DURATION_DAYS,
 DURATION_SECONDS,
 DURATION_MILLISECONDS,
 DURATION_MICROSECONDS,
 DURATION_NANOSECONDS,
 DICTIONARY32,
 STRING,
 LIST,
 DECIMAL32,
 DECIMAL64,
 DECIMAL128,
 STRUCT,
 // `NUM_TYPE_IDS` must be last!
 NUM_TYPE_IDS
};

class data_type {
 public
 data_type() = default;
 ~data_type() = default;
 data_type(data_type const&) = default;
 data_type(data_type&&) = default;

 data_type& operator=(data_type const&) = default;

 data_type& operator=(data_type&&) = default;

 CUDF_HOST_DEVICE explicit constexpr data_type(type_id id) : _id{id} {}

 explicit data_type(type_id id, int32_t scale) : _id{id}, _fixed_point_scale{scale}
 {
 assert(id == type_id::DECIMAL32 || id == type_id::DECIMAL64 || id == type_id::DECIMAL128);
 }

 [[nodiscard]] CUDF_HOST_DEVICE constexpr type_id id() const noexcept { return _id; }

 [[nodiscard]] CUDF_HOST_DEVICE constexpr int32_t scale() const noexcept
 {
 return _fixed_point_scale;
 }

 private
 type_id _id{type_id::EMPTY};

 // Below is additional type specific metadata. Currently, only _fixed_point_scale is stored.

 int32_t _fixed_point_scale{}; // numeric::scale_type not available here, use int32_t
};

constexpr bool operator==(data_type const& lhs, data_type const& rhs)
{
 // use std::tie in the future, breaks JITIFY currently
 return lhs.id() == rhs.id() && lhs.scale() == rhs.scale();
}

inline bool operator!=(data_type const& lhs, data_type const& rhs) { return !(lhs == rhs); }

std::size_t size_of(data_type t);

} // namespace CUDF_EXPORT cudf