File size: 3,735 Bytes
a66b2f4 c153151 cdbc011 a66b2f4 dc518c2 23c6cd4 dc518c2 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 |
---
configs:
- config_name: default
data_files:
- split: runtime_filtered
path: "backend_bench_problems_runtime_filtered.parquet"
- split: runtime_filtered_scaling_factor_2
path: "backend_bench_problems_runtime_filtered_threshhold_2.parquet"
- split: benchmark
path: "backend_bench_problems.parquet"
---
# Understanding Trace Files in BackendBench
## Format
Trace files capture PyTorch operations and their 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`**: This 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})`
## Complete 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 64×256 tensor
## Interpretation
Trace files provide real-world operation usage patterns, showing which tensor shapes and operations are most common in actual PyTorch models. These are fairly useful for debugging.
**Note: These may be deprecated in the future, but are described as they are currently included in the dataset / codebase.**
# Understanding Serialized Arguments in BackendBench
## Format
BackendBench stores function arguments as strings containing all parameters needed to reproduce PyTorch operations:
```
((arg1, arg2, ...), {'key1': val1, 'key2': val2})
```
## 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)
## Complete Examples
**Single tensor argument:**
```python
((T([48, 24, 28, 28], f16),), {})
```
= Function called with one 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)), {})
```
= Function with two identical 5D tensors
**Mixed arguments:**
```python
((T([128, 256], f16), [1024, 249, 249]), {'dtype': torch.float16, 'device': 'cuda'})
```
= Function with tensor, list, and keyword arguments
**Complex nested:**
```python
(([T([5, 5], f32), T([3, 3], i64), 42],), {'weight': T([3, 3], f32)})
```
= Function with list containing tensors and numbers, plus tensor keyword argument
## Argument Types
- **Tensors**: `T([shape], dtype)` format
- **Lists**: `[item1, item2, ...]` (can contain tensors)
- **Primitives**: `42`, `'hello'`, `True`, `None`
- **PyTorch objects**: `torch.float16`, `torch.strided`
## Acknowledgements
We are extremely grateful for the folks working on [TritonBench](https://github.com/pytorch-labs/tritonbench/tree/main) for these traces and intuitive format |