Ready to use
Daisytuner Platform

Everything in place to start optimizing.

The Cloud Console, the DOCC compiler, benchmarking on real hardware and your Performance Database are ready when you sign in. Connect your code and see your first results today.

Ready when you sign inOpen-source compilerReal hardware
DOCC compiler

Support for the languages you love.

The docc compiler meets your code where it is. Decorate a NumPy-style kernel, route a PyTorch module through torch.compile, or compile a C/C++ translation unit like you would with clang. Same compiler, same IR, no rewrites.

jacobi_2d.py
1from docc.compiler import native
2
3@docc.native(target="sequential")
4def kernel(TSTEPS, A, B):
5 for t in range(1, TSTEPS):
6 B[1:-1, 1:-1] = 0.2 * (
7 A[1:-1, 1:-1] + A[1:-1, :-2] + A[1:-1, 2:] + A[2:, 1:-1] + A[:-2, 1:-1]
8 )
9 A[1:-1, 1:-1] = 0.2 * (
10 B[1:-1, 1:-1] + B[1:-1, :-2] + B[1:-1, 2:] + B[2:, 1:-1] + B[:-2, 1:-1]
11 )
$python jacobi_2d.py
Continuous benchmarking

Measure performance on every commit.

Every push carries your workloads straight from GitHub into the performance dashboard of our Cloud Console. We run them on real hardware, surface the hotspots, and place each part of your code on the roofline of the hardware, so you see where time goes and what limits it.

daisytuner/modelsmain · 6d6dbefPerformance dashboard2 workloads · todayLive
pytorch_models2 workloads
VariantRegionsRuntimeSpeedupΔ Base
torch—78.0 ms+3.0%
torch-cuda—17.9 ms−7.5%
docc-cuda93 regions11.2 ms1.60×+0.0%
docc-omp45 regions41.5 ms1.88×−1.8%
VariantRegionsRuntimeSpeedupΔ Base
torch-cuda—36.4 ms−3.4%
docc-cuda266 regions21.7 ms1.68×+0.6%
Roofline · segformer::docc-cudadraml2l1
0.010.11101001k10k1101001k10k100kfp64 · 411 GFLOP/sfp32 · 25.8k GFLOP/sDRAM · 465 GB/stensor_fp16 · 243k GFLOP/ssegformer.py · hot region48.4 GFLOP/s @ 0.227 FLOP/Bdram-bound · 46% of peak
From the DashboardHot region found on the roofline → opened in the Editor
Web IDE

Performance optimizations, reviewed like code.

Our compiler, docc, represents every code as a dataflow IR that makes data movement, parallelism and computation explicit. In the web IDE of our Cloud Console you compose optimization recipes yourself. The compiler checks each recipe for legality, and you're ready to open the result as a pull request.

Dataflow IRProvably legal transformationsChecks on real hardware
Cloud Console · Pull requests

[segformer] fused gemm and div

MergedServerCUDA
__docc_GraphModule:2398 · 4 loops · 3 maps · depth 4
Initial SDFG · 5 steps
map [SEQUENTIAL]: _b41 = 0; (_b41 < 16); _b41++
map [SEQUENTIAL]: _j55 = 0; (_j55 < 160); _j55++
map [SEQUENTIAL]: _i1857 = 0; (_i1857 < 256); _i1857++
for: _k93 = 0; (_k93 < 160); _k93++
_copy13_out = _a * _b + _c_sum55
_sum55_out = _in_tmp31
_tmp31_out = _a / _b_copy2
From the EditorPull request merged → recipe indexed as a performance embedding
Performance Database

A live database, queried by docc.

Your performance database stores every optimization recipe, and docc matches them against your code automatically during compilation. Purpose-built performance embeddings find similar regions and the ideal optimization for yours. A RAG method for compilers.

Illustrative data · t-SNE of performance embeddings
Embedding mapPR · fused gemm and div
Pinned kernelPublished
kernelsegformer.fused_gemm_div
sourcepull request · merged
targetCUDA
scheduleinterchange ×2 · CUDA(32) · nested(8, 4)
legalitypolyhedral · proven
speedup2.14×
gap to I/O bound9%
neighbours3 · transfer-tunable
Kernels274in view
Tuned48%of kernels in view
Avg speedup2.01×tuned in view
Targets4in view
Get started

Three steps to your first results.

  1. 01Sign inOpen the Cloud Console. Runners, the web IDE and your database are already set up.Open the Cloud Console →
  2. 02Connect your codeLink a GitHub repository, or install docc locally with one command.Install docc →
  3. 03Push and optimizeEvery push is compiled, benchmarked on real hardware and ready to optimize in the browser.Read the docs →

Open the console and start optimizing.