jrhemstad

namespace nvtx3{

enum class heap_kind{
   LINEAR,
   3D,
   ARRAY
};

struct heap_type{

jrhemstad

namespace {

device_memory_resource* cuda_resource() {
  static cuda_memory_resource resource{};
  return &resource;

  std::atomic<device_memory_resource*>& get_default() {
    static std::atomic<device_memory_resource*> res{detail::cuda_resource()};
    return res;
  }

jrhemstad

• String Column Factory

  • make_string_column(...)
  • What are the necessary inputs?
  • Do we need more than one factory for String columns for different inputs?

• String column wrapper type

  • There should be a type, cudf::string_column that is a thin wrapper around cudf::column that encodes behavior unique to string columns, e.g., it abstracts which children are offsets vs characters, etc.
  • Example usage would be something like:

    unique_ptr<cudf::column> col = make_string_column(...);
    

jrhemstad

We'd like to better understand if and when using libcudf's type_dispatcher adds overhead when used in both host and device code.

In order to test this, we'd like to create a set of micro-benchmarks to profile the performance of operating on a set of n gdf_column objects.

To keep the benchmark simple, the work of each kernel will be simply applying some in-place transformation functor to every element of every column. For example:

template <template typename<> UnaryFunctor>
benchmark(cudf::table input){

jrhemstad

How to Use Ninja

1. Install Ninja

sudo apt install ninja-build

2. Configure CMake to create Ninja build files

mkdir build && cd build

jrhemstad

namespace detail
{

  inline memory_resource* default_resource(){
    static memory_resource res();
    return &res;
  }
  
  inline std::atomic<memory_resource*>& get_global()
  {

jrhemstad

In order to facilitate conversation about the different kinds of aggregations that can be performed via groupby, it is important to be clear on the following terms:

Distributive

An aggregate function is distributive when it can be computed in a distributed manner. For example, assume that a data set is partitioned into n sets. The distributive aggregate function is applied to each set resulting in n aggregate values. If the aggregate value of the whole data set can now be computed by applying the same aggregate function to all the set aggregate values then the aggregate function is distributive. Examples of distributive aggregate functions are sum(), count(), min(), and max().

jrhemstad

Overview

As libcudf transitions from a C API to C++ API, this is a list of guidance on what should be done for all new PRs against libcudf.

File Structure

In lieu of the monolithic functions.h, external function APIs should be grouped based on functionality into an appropriately titled header file cudf/cpp/include/. For example, cudf/cpp/include/copying.hpp contains the APIs for functions related to copying from one column to another. Note the .hpp file extension used to indicate a C++ header file.

jrhemstad

Problem Statement:

We want to write an algorithm once and allow it to work on a variety of columns.

The kinds of columns include:

• Elements are fixed-width types (int8, int32, float, double, date32, timestamp, etc.)
• Elements are variable length (strings, …)
• “Dictionary” columns
• Elements in the column are indices into a dictionary
• Elements are fixed-size structs