task_id stringlengths 4 32 | category stringclasses 6
values | difficulty int64 1 4 | interface_mode stringclasses 1
value | tags stringlengths 31 97 | scales_available stringclasses 1
value | cpu_ms_small float64 0.38 5.58k | cpu_ms_medium float64 8.35 19.8k | cpu_ms_large float64 176 2.78M | source stringlengths 5 92 | description stringlengths 71 320 | cpu_source stringlengths 831 46.6k | prompt_yaml stringlengths 963 7.57k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
batched_lhpca_portfolio | Financial computing | 3 | compute_only | finance,linear-algebra,pca,portfolio-optimization,batched | small,medium,large | 132.437 | 19,839.334 | 28,236.943 | Anderson, Kim \ | Ryu 2026, "Long-History Principal Component Analysis in a Dynamic Factor Model with Weak Loadings," Operations Research: https://doi.org/10.1287/opre.2024.1134 & Batched long-history PCA portfolio optimization from historical return matrices, requiring dense linear algebra and repeated portfolio-weight computation. | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
void solution_compute(int S, int T, int N, int K, const float* R, float* w) {
float* R_norm = (float*)malloc(T * N * sizeof(float));
float* M = (float*)malloc(T * T * sizeof(float));
float* Phi = (float*)malloc(T * K * sizeof(float));
float* Z = ... | task_description: |
In portfolio optimization, estimating the covariance matrix of asset returns is critical but challenging due to noise and finite-sample errors. Long-History Principal Component Analysis (LH-PCA) mitigates these issues by extracting latent risk factors over an extended data history.
This task ... |
black_scholes | Financial computing | 1 | compute_only | option_pricing,embarrassingly_parallel,transcendental_math | small,medium,large | 7.259 | 442.792 | 867.644 | FinanceBench: https://github.com/cavazos-lab/FinanceBench | Analytic Black--Scholes option-pricing engine over large independent option batches. | // cpu_reference.c — Black-Scholes option pricing (CPU baseline)
//
// Faithfully ported from FinanceBench/Black-Scholes/CPU/
// blackScholesAnalyticEngineKernelsCpu.c
// blackScholesAnalyticEngineStructs.h
// errorFunctConsts.h
//
// Preserves original struct definitions, function names, and computation flow.
//... | # Black-Scholes Analytic Option Pricing -- Prompt Template
task_description: |
Compute Black-Scholes option prices for N European options using the analytic formula.
Each option has parameters: type (CALL=0/PUT=1), strike price (K), spot price (S),
dividend yield (q), risk-free rate (r), time to maturity (t), an... |
bonds_pricing | Financial computing | 1 | compute_only | bond_pricing,yield_curve,newton_raphson,day_count,cash_flows | small,medium,large | 1,173.09 | 11,751.596 | 23,524.434 | FinanceBench: https://github.com/cavazos-lab/FinanceBench | Fixed-rate bond valuation with yield-related quantities, dirty price, clean price, and accrued amount. | // cpu_reference.c -- bonds_pricing CPU baseline
//
// Faithful port of FinanceBench bondsKernelsCpu.c / bondsStructs.h.
// Pure C. NO C++, NO references, NO new, NO file I/O, NO main.
//
// C++ function overloads from the original are renamed:
// closeCpu(x,y) -> closeCpu(x,y) (calls closeCpu2 with n=42)
// clo... | # Fixed-Rate Bond Pricing -- Prompt Template
task_description: |
Given N fixed-rate bonds, compute for each bond:
1. **Yield-to-maturity** (bond forward value) via a Newton-Raphson/Brent hybrid solver
2. **Dirty price** (present value of all cash flows using the computed yield curve)
3. **Accrued amount** (int... |
monte_carlo | Financial computing | 2 | compute_only | option_pricing,stochastic_simulation,random_number_generation | small,medium,large | 1,332.731 | 13,341.081 | 26,713.484 | FinanceBench: https://github.com/cavazos-lab/FinanceBench | Monte Carlo option-pricing workload based on independent stochastic path simulation and payoff aggregation. | // cpu_reference.c — Monte Carlo option pricing (CPU baseline)
//
// Faithfully ported from FinanceBench/Monte-Carlo/CPU/monteCarloKernelsCpu.c
// Preserves original variable names, function structure, and computation flow.
//
// Key change from original: uses deterministic xorshift32 RNG instead of rand()
// to ensure... | # Monte Carlo Option Pricing -- Prompt Template
task_description: |
Compute Monte Carlo option prices for N independent simulation paths using
geometric Brownian motion. Each path simulates the underlying asset price over
a number of time steps, then computes the discounted payoff of a put option.
The simulat... |
repo_pricing | Financial computing | 2 | compute_only | repo_pricing,bond_pricing,yield_solver,date_arithmetic,forward_pricing | small,medium,large | 743.36 | 7,411.776 | 37,241 | FinanceBench: https://github.com/cavazos-lab/FinanceBench | Repurchase-agreement pricing from bond valuation and repo forward-pricing components. | // cpu_reference.c -- repo_pricing CPU baseline
//
// Repurchase agreement pricing: bond yield solver + repo forward calculations.
// Faithfully ported from FinanceBench Repo/CPU/repoKernelsCpu.c + repoStructs.h + repoEngine.c.
// Pure C. NO C++, NO references, NO new, NO file I/O, NO main.
#include <stdlib.h>
#includ... | # Repurchase Agreement Pricing -- Prompt Template
task_description: |
Given N repurchase agreements (repos), compute for each repo:
1. **Bond yield-to-maturity** via Newton-Raphson/Brent hybrid solver
2. **Dirty price** and **clean price** of the underlying bond
3. **Accrued amounts** at settlement and deliver... |
miniWeather | HPC reference | 4 | compute_only | stencil,CFD,finite_volume,Runge_Kutta,halo_exchange,reduction,double_precision | small,medium,large | 907.979 | 14,465.628 | 2,033,374.25 | miniWeather: https://github.com/mrnorman/miniWeather | Two-dimensional compressible-fluid mini-application reporting conservation metrics and numerical error norms. | // cpu_reference.c — miniWeather CPU baseline (compute_only interface)
//
// Adapted from miniWeather_standalone.cpp by Matt Norman (ORNL).
// Simulates dry, stratified, compressible, non-hydrostatic fluid flows.
// All compile-time constants converted to runtime parameters.
//
// Build: gcc -O2 -DORBENCH_COMPUTE_ONLY ... | # miniWeather — Prompt Template
task_description: |
Simulate 2D dry, stratified, compressible, non-hydrostatic fluid dynamics using the
finite-volume method with Strang-split dimensional splitting and 3-stage Runge-Kutta
time integration.
The simulation tracks 4 fluid state variables (density perturbation, x-... |
hpcg_spmv_27pt | HPC reference | 2 | compute_only | hpcg,spmv,csr,27_point_stencil,sparse_matrix_vector | small,medium,large | 0.439 | 8.352 | 412.584 | HPCG: https://github.com/hpcg-benchmark/hpcg | Sparse matrix--vector multiplication on the 27-point structured stencil matrix used by HPCG. | #include <stddef.h>
static int g_n = 0; static const int *g_row_ptr = 0; static const int *g_col_idx = 0; static const double *g_values = 0; static const double *g_x = 0;
static void _orbench_old_init(int n, const int *row_ptr, const int *col_idx, const double *values, const double *x) { g_n=n; g_row_ptr=row_ptr; g_col... | task: hpcg_spmv_27pt
summary: >
Implement a GPU solution for the HPCG reference sparse matrix-vector product.
The matrix comes from the official 27-point 3D stencil construction and is
provided in CSR format. Compute y = A x exactly.
inputs:
- row_ptr: int32[n+1]
- col_idx: int32[nnz]
- values: float64[nnz]... |
hpcg_symgs_sweep | HPC reference | 3 | compute_only | hpcg,symgs,gauss_seidel,csr,27_point_stencil,sparse_solver | small,medium,large | 1.207 | 18.979 | 197.602 | HPCG: https://github.com/hpcg-benchmark/hpcg | One forward and backward symmetric Gauss--Seidel sweep on an HPCG-style sparse matrix. | #include <stddef.h>
static int g_n = 0;
static const int *g_row_ptr = 0;
static const int *g_col_idx = 0;
static const double *g_values = 0;
static const int *g_diag_idx = 0;
static const double *g_rhs = 0;
static void _orbench_old_init(int n, const int *row_ptr, const int *col_idx,
const double *v... | task: hpcg_symgs_sweep
summary: >
Implement a GPU solution for one HPCG-style symmetric Gauss-Seidel sweep on
a CSR matrix generated from the official 27-point 3D stencil construction.
The kernel must perform one forward sweep and one backward sweep using the
provided right-hand side and initial guess.
inputs:
... |
hpcg_mg_vcycle | HPC reference | 4 | compute_only | hpcg,multigrid,v_cycle,csr,27_point_stencil,symgs,restriction,prolongation | small,medium,large | 4.152 | 61.937 | 180.04 | HPCG: https://github.com/hpcg-benchmark/hpcg | Multigrid V-cycle with smoothing, restriction, coarse-grid correction, and prolongation on an HPCG-style stencil matrix. | #include <stdlib.h>
#include <string.h>
#include <stdio.h>
typedef struct {
int nx, ny, nz, n;
int owns_matrix;
const int *row_ptr;
const int *col_idx;
const double *values;
const int *diag_idx;
int *row_ptr_owned;
int *col_idx_owned;
double *values_owned;
int *diag_idx_owned;
... | task: hpcg_mg_vcycle
summary: >
Implement a GPU solution for one HPCG-style multigrid V-cycle on a CSR matrix
generated from the official 27-point 3D stencil construction. The hierarchy is
geometric with three coarse levels, symmetric Gauss-Seidel pre/post smoothing,
injection restriction of the residual, and c... |
npb_cg_sparse_solve | HPC reference | 3 | compute_only | sparse_matrix,csr,conjugate_gradient,spmv,reductions,iterative_solver | small,medium,large | 2.567 | 124.943 | 1,178.354 | NPB3.0-omp-C: https://github.com/benchmark-subsetting/NPB3.0-omp-C | "Sparse conjugate-gradient solve with irregular sparse-matrix access and residual-based convergence (...TRUNCATED) | "#include <stdlib.h>\n#include <string.h>\n#include <math.h>\n#include <stdio.h>\n\ntypedef struct {(...TRUNCATED) | "task: npb_cg_sparse_solve\nsummary: >\n Implement a GPU solution for a sparse conjugate-gradient b(...TRUNCATED) |
End of preview. Expand in Data Studio
AccelEval — Reviewer Sample (small split only)
A representative sample of AccelEval provided per NeurIPS 2026 dataset-hosting guidelines for reviewers inspecting a >4 GB dataset.
⚠️ This dataset is uploaded anonymously to support a double-blind conference submission. Author information is intentionally omitted.
Relationship to the full dataset
| Sample (this repo) | Full dataset | |
|---|---|---|
| Tasks | All 42 tasks | All 42 tasks |
| Scales | small only |
small, medium, large |
| Packed size | ~30 MB | ~12 GB |
| Manifest | tasks.parquet, tasks.csv (full) |
identical |
| URL | this repo | Accel-Eval/AccelEval-data |
The two repos share an identical 42-row tasks.parquet (the manifest is
not affected by which scales ship), so reviewers can browse every task's
metadata, full cpu_reference.c source, and L1/L2/L3 prompt_template.yaml
directly here without needing the larger tarballs.
How the sample was created
small.tar.gz is the unmodified small-scale tarball from the full
dataset — same SHA256, same byte layout. Specifically, every task's
gen_data.py is run with the parameters listed under "input_sizes.small"
in tasks/<task_id>/task.json, with the deterministic seed
(seed=42); the resulting input.bin, expected_output.txt,
cpu_time_ms.txt, and requests.txt files for all 42 tasks are then
packed under tasks/<task_id>/data/small/... into a single
gzipped tar. The same code path produces medium.tar.gz and
large.tar.gz in the full dataset; this sample simply omits those two
tarballs.
The manifest.json shipped here contains the SHA256 of small.tar.gz,
which matches the entry for small.tar.gz in the full dataset's
manifest.json.
What's in this repo
| File | Role |
|---|---|
tasks.parquet |
The 42-task manifest (browseable above), 13 columns. Includes the full cpu_reference.c source and the LLM prompt_template.yaml for every task so the benchmark is self-contained at the metadata level. |
tasks.csv |
Same content as tasks.parquet, plain text. |
small.tar.gz |
All 42 tasks at the small scale (~30 MB packed). |
manifest.json |
SHA256 of small.tar.gz + per-task metadata. |
small.tar.gz expands to tasks/<task_id>/data/small/{input.bin, expected_output.txt, cpu_time_ms.txt, requests.txt}.
Quick load (manifest table)
import pandas as pd
tasks = pd.read_parquet("hf://datasets/Accel-Eval/AccelEval-sample/tasks.parquet")
print(tasks.head())
Pulling the small inputs
huggingface-cli download Accel-Eval/AccelEval-sample small.tar.gz \
--repo-type dataset --local-dir .
tar xzf small.tar.gz # populates tasks/<task>/data/small/
Or via the companion code repo's helper:
ACCELEVAL_HF_REPO=Accel-Eval/AccelEval-sample \
python3 scripts/download_data.py small
Categories (same as the full dataset)
| Category | Count | Examples |
|---|---|---|
| Operations research | 12 | crew_pairing, network_rm_dp, pdlp, gittins_index, ... |
| Graph algorithms | 7 | bellman_ford, held_karp_tsp, gapbs_pagerank_pullgs, ... |
| Spatial--temporal | 7 | dbscan, dtw_distance, euclidean_distance_matrix, ... |
| HPC reference | 7 | hpcg_spmv_27pt, npb_lu_ssor_structured, miniWeather, ... |
| Financial computing | 5 | black_scholes, bonds_pricing, monte_carlo, ... |
| Scientific simulation | 4 | sph_cell_index, sph_forces, sph_position, hotspot_2d |
The full row-by-row description is in tasks.parquet.
Determinism
Every task generator uses a fixed seed (seed=42 in gen_data.py); the
tarball in this repo is byte-reproducible from the code repo's
tasks/<task>/gen_data.py. The manifest.json ships SHA256 hashes so
an independent regeneration can be verified bit-exactly.
License
Released under Apache-2.0. Each individual task adapts code from a
publicly available source (GitHub repository or published research paper);
the original sources retain their respective licenses, and tasks.parquet
records each source for attribution.
- Downloads last month
- 13