| --- |
| configs: |
| - config_name: torchbench |
| data_files: |
| - split: benchmark |
| path: "backend_bench_problems.parquet" |
| - config_name: ops_traces_models |
| data_files: |
| - split: operator_input_models |
| path: "operator_input_models_mapping.parquet" |
| --- |
| |
| # TorchBench |
|
|
| The TorchBench suite of [BackendBench](https://github.com/meta-pytorch/BackendBench) is designed to mimic real-world use cases. It provides operators and inputs derived from 155 model traces found in [TIMM](https://huggingface.co/timm) (67), [Hugging Face Transformers](https://huggingface.co/docs/transformers/en/index) (45), and [TorchBench](https://github.com/pytorch/benchmark) (43). (These are also the models PyTorch developers use to [validate performance](https://hud.pytorch.org/benchmark/compilers).) You can view the origin of these traces by switching the subset in the dataset viewer to `ops_traces_models` and `torchbench` for the full dataset. |
|
|
| When running BackendBench, much of the extra information about what you are testing is abstracted away, so you can simply run `uv run python --suite torchbench ...`. Here, however, we provide the test suite as a dataset that can be explored directly. It includes details about why certain operations and arguments were included or excluded, reflecting the careful consideration behind curating the set. |
|
|
| You can download the dataset in either format: |
|
|
| - `backend_bench_problems.parquet` (default format on Hugging Face) |
| |
| - `backend_bench_problems.json` (more human-readable) |
| |
| |
| ### Fields |
|
|
| - **uuid** – Unique identifier for the `(op_name, args)` pair. |
| |
| - **op_name** – Full name of the operator being tested. |
| |
| - **args** – Serialized form of the inputs from the trace. [See details below](#serialized-arguments-in-backendbench). |
| |
| - **runnable** – Whether the operator is runnable in BackendBench (some are not yet supported). |
| |
| - **included_in_benchmark** – Whether this `(op_name, args)` pair is tested in the TorchBench suite. |
| |
| - **why_excluded** – If not included, a list of reasons for exclusion (e.g., "BackendBench does not support correctness testing for random ops yet," "BackendBench does not support correctness testing for tensor creation and manipulation ops yet"). |
| |
| - **is_synthetic** – Marks synthetically generated inputs (e.g., very large tensors). These are currently excluded from the benchmark. |
| |
| - **runtime_ms** – Execution time (ms) on our hardware (single GPU from a machine with 8× H100s and an AMD EPYC 9654 96-core processor). |
| |
| - **relative_runtime_to_kernel_launch** – `runtime_ms` divided by the runtime of a dummy CUDA op (`torch.empty(0, device=cuda)`), representing launch overhead. |
| |
| - **is_overhead_dominated_op** – Flags operator/argument pairs running close to CUDA overhead as “performance canaries.” [Histogram analysis](https://github.com/meta-pytorch/BackendBench/issues/108) showed that a 1.3× threshold above CUDA overhead is a useful cutoff. These tests can be run for sanity-checking kernels with `uv run python --suite torchbench --check-overhead-dominated-ops ...`. |
| |
| - **count** – Number of times this operator/input pair appeared in model traces. |
| |
| - **in_models** – List of models (from real-world traces) where this operator/input pair appears. |
| |
| - **in_models_count** – Number of distinct models in which this operator/input pair occurs. |
| |
| |
| # Serialized Arguments in BackendBench |
|
|
| Generally, arguments are serialized by storing tensor shapes and preserving everything else as it's fairly intuitive. For example: |
|
|
| `((T([8, 8, 8, 8, 8], f16), T([8, 8, 8, 8, 8], f16)), {})` |
|
|
| Below we'll go into detail about the format for rigor. |
| ## Format |
|
|
| BackendBench stores function arguments as strings with all parameters needed to reproduce PyTorch operations: |
|
|
| ```python |
| ((arg1, arg2, ...), {'key1': val1, 'key2': val2}) |
| ``` |
|
|
| ```python |
| (([T([5, 5], f32), T([3, 3], i64), 42],), {'weight': T([3, 3], f32)}) |
| ``` |
|
|
| ## Tensor Representation |
|
|
| Tensors use the format `T([shape], dtype)` or `T([shape], dtype, [stride])`: |
|
|
| ```python |
| T([10, 20], f32) # 10×20 float32 tensor |
| T([1, 512, 768], f16) # 1×512×768 float16 tensor |
| T([64], i32) # 64-element int32 vector |
| ``` |
|
|
| **Data types**: `f16/f32/f64` (float), `bf16` (bfloat16), `i32/i64` (int), `b8` (bool) |
|
|
| ## Examples |
|
|
| **Single tensor argument:** |
|
|
| ```python |
| ((T([48, 24, 28, 28], f16),), {}) |
| ``` |
|
|
| 48×24×28×28 float16 tensor, no keyword arguments |
|
|
| **Multiple tensors:** |
|
|
| ```python |
| ((T([8, 8, 8, 8, 8], f16), T([8, 8, 8, 8, 8], f16)), {}) |
| ``` |
|
|
| Two 5D tensors of identical shapes |
|
|
| **Mixed arguments:** |
|
|
| ```python |
| ((T([128, 256], f16), [1024, 249, 249]), {'dtype': torch.float16, 'device': 'cuda'}) |
| ``` |
|
|
| Args are a tensor, list, and keyword arguments |
|
|
| **Complex nested:** |
|
|
| ```python |
| (([T([5, 5], f32), T([3, 3], i64), 42],), {'weight': T([3, 3], f32)}) |
| ``` |
|
|
| List containing tensors and numbers, plus tensor keyword argument |
|
|
| ## Argument Types |
|
|
| - **Tensors**: `T([shape], dtype)` |
| |
| - **Lists**: `[item1, item2, ...]` (can contain tensors) |
| |
| - **Primitives**: `42`, `'hello'`, `True`, `None` |
| |
| - **PyTorch objects**: `torch.float16`, `torch.strided` |
| |
| |
| # Trace Files in BackendBench |
|
|
| This repository includes `.txt` trace files, which were the original output format of model traces and are used to compose the dataset. Here’s their structure: |
|
|
| ## Format |
|
|
| Trace files capture PyTorch operations and arguments from real model executions: |
|
|
| ``` |
| Operator: operation_name |
| cnt: count, serialized_arguments |
| cnt: count, serialized_arguments |
| ... |
| ``` |
|
|
| ## Structure |
|
|
| **Operator line**: Specifies the PyTorch operation |
|
|
| ``` |
| Operator: aten.add.Tensor |
| Operator: aten.relu.default |
| Operator: aten.linear.default |
| ``` |
|
|
| **Count lines**: Show how often each argument combination was used |
|
|
| ``` |
| cnt: 42, ((T([10, 20], f16), T([10, 20], f16)), {}) |
| cnt: 0, ((T([5, 5], f32), T([5, 5], f32)), {}) |
| ``` |
|
|
| ## Reading Count Lines |
|
|
| - **Count `42`**: Argument combination appeared 42 times in traced models |
| |
| - **`cnt: 0`** = Synthetic/generated arguments (not from real models) |
| |
| - **`cnt: >0`** = Real usage frequency from model traces |
| |
| |
| **Arguments**: Same format as serialized arguments – `((args), {kwargs})` |
|
|
| ## Example |
|
|
| ``` |
| Operator: aten.add.Tensor |
| cnt: 156, ((T([1, 512, 768], f16), T([1, 512, 768], f16)), {}) |
| cnt: 89, ((T([32, 128], f32), T([32, 128], f32)), {}) |
| cnt: 0, ((T([10, 10], f16), T([10, 10], f16)), {}) |
| |
| Operator: aten.relu.default |
| cnt: 234, ((T([64, 256], f16),), {}) |
| ``` |
|
|
| This shows: |
|
|
| - `aten.add.Tensor` called 156 times with 1×512×768 tensors |
| |
| - Same operation called 89 times with 32×128 tensors |
| |
| - One synthetic test case (`cnt: 0`) |
| |
| - `aten.relu.default` called 234 times with a 64×256 tensor |
| |
| |
| **Note: Traces may be deprecated in the future, but are described here as they are currently included in the dataset/codebase.** |
|
|
| # Acknowledgements |
|
|
| We are extremely grateful to the [TritonBench](https://github.com/pytorch-labs/tritonbench/tree/main) team for these traces and their intuitive format. |
