Skip to content

MichelRojo86WPP/copilot-config / skills/accelerated-computing-cudf

accelerated-computing-cudf

Verified

Official NVIDIA-authored guidance for NVIDIA cuDF GPU DataFrames, pandas acceleration, dask-cuDF, ETL, joins, groupby, CSV/Parquet I/O, nullable semantics, and multi-GPU DataFrame workloads.

FileKindSize
BENCHMARK.mdmarkdown4.2 KB
SKILL.mdskill md9.2 KB
evals/evals.jsonconfig15.8 KB
evals/files/cudf-apply-udf/code/generate_data.pyscript1.5 KB
evals/files/cudf-apply-udf/code/udf_pipeline.pyscript5.3 KB
evals/files/cudf-csv-etl/code/etl_pipeline.pyscript2.6 KB
evals/files/cudf-csv-etl/code/generate_data.pyscript1.2 KB
evals/files/cudf-groupby-agg/code/generate_data.pyscript1.4 KB
evals/files/cudf-groupby-agg/code/groupby_analysis.pyscript4.3 KB
evals/files/cudf-multi-join/code/generate_data.pyscript2.0 KB
evals/files/cudf-multi-join/code/multi_join.pyscript3.6 KB
evals/files/cudf-native-stream-handoff-boundary/NOTICE.mdmarkdown344 B
evals/files/cudf-native-stream-handoff-boundary/code/run_smoke.shscript464 B
evals/files/cudf-native-stream-handoff-boundary/code/threaded_handoff.cuother3.9 KB
evals/files/cudf-null-handling/code/generate_data.pyscript2.1 KB
evals/files/cudf-null-handling/code/null_pipeline.pyscript4.7 KB
evals/files/cudf-parquet-io/code/generate_data.pyscript2.0 KB
evals/files/cudf-parquet-io/code/parquet_pipeline.pyscript4.3 KB
evals/files/cudf-pivot-melt/code/generate_data.pyscript1.4 KB
evals/files/cudf-pivot-melt/code/reshape_analysis.pyscript4.6 KB
evals/files/cudf-string-ops/code/clean_contacts.pyscript3.4 KB
evals/files/cudf-string-ops/code/generate_data.pyscript2.7 KB
evals/files/cudf-timeseries-resample/code/generate_data.pyscript1.5 KB
evals/files/cudf-timeseries-resample/code/timeseries_analysis.pyscript4.1 KB
evals/files/cudf-window-functions/code/generate_data.pyscript1.4 KB
evals/files/cudf-window-functions/code/window_analysis.pyscript5.1 KB
evals/files/negative-deep-learning-training/code/train.pyscript1.4 KB
evals/files/source-cudf-null-fillna-semantics/NOTICE.mdmarkdown342 B
evals/files/source-cudf-null-fillna-semantics/code/null_cleanup.pyscript1.4 KB
references/api-patterns.mdmarkdown6.9 KB
references/cudf-pandas-accelerator.mdmarkdown3.6 KB
references/dask-cudf-patterns.mdmarkdown7.0 KB
skill-card.mdmarkdown4.0 KB
skill.oms.sigother12.2 KB

evals/files/cudf-native-stream-handoff-boundary/code/threaded_handoff.cu

View on GitHub
/*
 * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 */

#include <cuda_runtime.h>

#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <memory>

namespace {

constexpr int kRows = 1 << 20;
constexpr int kValue = 7;
constexpr int kTrials = 32;

void check_cuda(cudaError_t status, const char* what)
{
  if (status != cudaSuccess) {
    std::fprintf(stderr, "%s failed: %s\n", what, cudaGetErrorString(status));
    std::abort();
  }
}

__global__ void fill_kernel(int* data, int rows, int value)
{
  int idx = blockIdx.x * blockDim.x + threadIdx.x;
  if (idx >= rows) return;

  int adjusted = value;
  for (int spin = 0; spin < 4096; ++spin) {
    adjusted += (spin & 1);
    adjusted -= (spin & 1);
  }
  data[idx] = adjusted;
}

__global__ void checksum_kernel(const int* data, std::uint64_t* out, int rows)
{
  int idx = blockIdx.x * blockDim.x + threadIdx.x;
  if (idx < rows) {
    atomicAdd(reinterpret_cast<unsigned long long*>(out),
              static_cast<unsigned long long>(data[idx]));
  }
}

struct NativeGpuTable {
  int* data{};
  int rows{};
  cudaStream_t producer_stream{};

  explicit NativeGpuTable(int row_count) : rows(row_count)
  {
    check_cuda(cudaStreamCreateWithFlags(&producer_stream, cudaStreamNonBlocking),
               "create producer stream");
    check_cuda(cudaMalloc(&data, sizeof(int) * rows), "allocate table data");
  }

  ~NativeGpuTable()
  {
    if (data != nullptr) {
      cudaFree(data);
    }
    if (producer_stream != nullptr) {
      cudaStreamDestroy(producer_stream);
    }
  }
};

std::shared_ptr<NativeGpuTable> build_table_async(int value)
{
  auto table = std::make_shared<NativeGpuTable>(kRows);
  int block = 256;
  int grid = (table->rows + block - 1) / block;
  fill_kernel<<<grid, block, 0, table->producer_stream>>>(table->data, table->rows, value);
  check_cuda(cudaGetLastError(), "launch fill kernel");
  return table;
}

std::uint64_t consume_on_stream(const std::shared_ptr<NativeGpuTable>& table,
                                cudaStream_t consumer_stream)
{
  std::uint64_t* d_sum{};
  std::uint64_t h_sum{};
  int block = 256;
  int grid = (table->rows + block - 1) / block;

  check_cuda(cudaMalloc(&d_sum, sizeof(std::uint64_t)), "allocate checksum");
  check_cuda(cudaMemsetAsync(d_sum, 0, sizeof(std::uint64_t), consumer_stream),
             "clear checksum");

  checksum_kernel<<<grid, block, 0, consumer_stream>>>(table->data, d_sum, table->rows);
  check_cuda(cudaGetLastError(), "launch checksum kernel");
  check_cuda(cudaMemcpyAsync(&h_sum,
                             d_sum,
                             sizeof(std::uint64_t),
                             cudaMemcpyDeviceToHost,
                             consumer_stream),
             "copy checksum");
  check_cuda(cudaStreamSynchronize(consumer_stream), "sync consumer stream");
  check_cuda(cudaFree(d_sum), "free checksum");
  return h_sum;
}

}  // namespace

int main()
{
  cudaStream_t consumer_stream{};
  check_cuda(cudaStreamCreateWithFlags(&consumer_stream, cudaStreamNonBlocking),
             "create consumer stream");

  std::uint64_t expected = static_cast<std::uint64_t>(kRows) * kValue;
  int failures = 0;

  for (int trial = 0; trial < kTrials; ++trial) {
    auto table = build_table_async(kValue);
    std::uint64_t actual = consume_on_stream(table, consumer_stream);
    if (actual != expected) {
      std::fprintf(stderr,
                   "trial %d checksum mismatch: got %llu expected %llu\n",
                   trial,
                   static_cast<unsigned long long>(actual),
                   static_cast<unsigned long long>(expected));
      ++failures;
    }
  }

  check_cuda(cudaStreamDestroy(consumer_stream), "destroy consumer stream");
  if (failures != 0) {
    std::fprintf(stderr, "%d stale handoff checks observed\n", failures);
    return 1;
  }
  std::puts("all handoffs matched expected checksum");
  return 0;
}
deprecation-and-migrationaddyosmani/agent-skillsManages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when migrating a database schema in production, such as renaming or dropping a column without downtime (expand/contract). Use when deciding whether to maintain or sunset existing code.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
performance-optimizationaddyosmani/agent-skillsOptimizes application performance across frontend, backend, queries, and databases. Use when performance requirements exist, when you suspect performance regressions, when Core Web Vitals or load times need improvement, when N+1 query patterns need fixing, or when profiling reveals bottlenecks.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
agent-cost-reportthedotmack/claude-memBelievable agent cost report for any period, default the last 7 full days PT, not counting today. Measured tokens from Claude Code transcripts priced at OpenRouter list prices (ESTIMATED), measured provider spend when a sanctioned source exists, note-taker cost separate, Timing-style HTML/PDF plus report.json, line-items.csv, evidence.json.Stars: 118kUpdated Claude CodeCodexVerifiedInstall
agent-cost-reportthedotmack/claude-memBelievable agent cost report for any period, default the last 7 full days PT, not counting today. Measured tokens from Claude Code transcripts priced at OpenRouter list prices (ESTIMATED), measured provider spend when a sanctioned source exists, note-taker cost separate, Timing-style HTML/PDF plus report.json, line-items.csv, evidence.json.Stars: 118kUpdated Claude CodeCodexVerifiedInstall