A high-throughput and memory-efficient inference and serving engine for LLMs
Mirrored from https://github.com/tduncan-lum/Nvidia-Optimization-Stack---VLLM.git
Synced Nov 4, 03:45 UTC
[Kernel][Helion] Optimize Helion config parsing latency (#40850)
Signed-off-by: Yanan Cao <gmagogsfm@gmail.com> Co-authored-by: Claude Sonnet 4 <noreply@anthropic.com>
Yanan Cao committed
May 7, 2026 at 20:27 UTC
0b999713522099cfdf0de57d42972369dddff053
13 files changed
+31837
-27941
tests/kernels/helion/helpers.py
+13
-5
@@ -6,24 +6,26 @@ import tempfile
6
from collections.abc import Callable
7
from contextlib import contextmanager
8
from pathlib import Path
9
+from typing import Any
10
from unittest.mock import patch
11
12
import helion
13
14
+from vllm.kernels.helion.case_key import CaseKey
15
from vllm.kernels.helion.config_manager import ConfigManager
16
from vllm.kernels.helion.register import register_kernel
17
from vllm.kernels.helion.utils import get_canonical_gpu_name
18
19
GPU_PLATFORM = get_canonical_gpu_name()
20
19
-DEFAULT_CONFIGS: dict[str, helion.Config] = {
20
- "default": helion.Config(block_sizes=[32]),
21
+DEFAULT_CONFIGS: dict[CaseKey, helion.Config] = {
22
+ CaseKey.default(): helion.Config(block_sizes=[32]),
23
}
24
25
26
@contextmanager
27
def dummy_kernel_registry(
26
- configs: dict[str, helion.Config] | None = None,
28
+ configs: dict[CaseKey, helion.Config] | None = None,
29
):
30
"""Context manager providing a register function with automatic config setup.
31
@@ -34,7 +36,13 @@ def dummy_kernel_registry(
36
"""
37
if configs is None:
38
configs = DEFAULT_CONFIGS
37
- config_data = {k: v.__dict__["config"] for k, v in configs.items()}
39
+
40
+ def _to_config_entries(cfgs: dict) -> list[dict[str, Any]]:
41
+ pairs: list[dict[str, Any]] = []
42
+ for k, v in cfgs.items():
43
+ config_data = v.__dict__["config"]
44
+ pairs.append({"key": dict(k), "config": config_data})
45
+ return pairs
46
47
with tempfile.TemporaryDirectory() as tmpdir:
48
config_dir = Path(tmpdir)
@@ -55,7 +63,7 @@ def dummy_kernel_registry(
63
kernel_dir = config_dir / name
64
kernel_dir.mkdir(parents=True, exist_ok=True)
65
(kernel_dir / f"{GPU_PLATFORM}.json").write_text(
58
- json.dumps(config_data)
66
+ json.dumps(_to_config_entries(configs))
67
)
68
return register_kernel(op_name, **kwargs)(fn)
69
tests/kernels/helion/test_autotune.py
+1
-1
@@ -63,7 +63,7 @@ class TestAutotuneDisabledKernel:
63
with dummy_kernel_registry(configs={}) as register:
64
wrapper = register(
65
"autotune_test_kernel",
66
- config_picker=lambda args, keys: "default",
66
+ config_picker=lambda args, keys: None,
67
fake_impl=lambda *a, **kw: None,
68
input_generator=lambda: {
69
"small": (
tests/kernels/helion/test_case_key.py
new
+68
@@ -0,0 +1,68 @@
1
+# SPDX-License-Identifier: Apache-2.0
2
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
3
+
4
+import pytest
5
+
6
+from vllm.utils.import_utils import has_helion
7
+
8
+if not has_helion():
9
+ pytest.skip(
10
+ "Helion is not installed. Install with: pip install vllm[helion]",
11
+ allow_module_level=True,
12
+ )
13
+
14
+from vllm.kernels.helion.case_key import CaseKey
15
+
16
+
17
+class TestCaseKey:
18
+ """Test suite for CaseKey class."""
19
+
20
+ def test_construction_with_dict(self):
21
+ key = CaseKey({"intermediate": 2048, "numtokens": 256})
22
+ assert key["intermediate"] == 2048
23
+ assert key["numtokens"] == 256
24
+
25
+ def test_empty_construction_raises(self):
26
+ with pytest.raises(TypeError, match="at least one key-value pair"):
27
+ CaseKey()
28
+ with pytest.raises(TypeError, match="at least one key-value pair"):
29
+ CaseKey({})
30
+
31
+ def test_default_construction(self):
32
+ key = CaseKey.default()
33
+ assert len(key) == 0
34
+ assert key.is_default()
35
+
36
+ def test_non_default_is_not_default(self):
37
+ key = CaseKey({"intermediate": 2048})
38
+ assert not key.is_default()
39
+
40
+ def test_hashable_and_equality(self):
41
+ a = CaseKey({"intermediate": 2048, "numtokens": 256})
42
+ b = CaseKey({"numtokens": 256, "intermediate": 2048})
43
+ assert a == b
44
+ assert hash(a) == hash(b)
45
+ assert a != CaseKey({"intermediate": 4096})
46
+ assert CaseKey.default() == CaseKey.default()
47
+
48
+ configs = {
49
+ CaseKey.default(): "default_config",
50
+ a: "a_config",
51
+ }
52
+ assert configs[b] == "a_config"
53
+ assert configs[CaseKey.default()] == "default_config"
54
+
55
+ def test_str_is_sorted_json(self):
56
+ assert str(CaseKey({"z": 1, "a": 2})) == '{"a":2,"z":1}'
57
+ assert str(CaseKey.default()) == "{}"
58
+
59
+ def test_immutable(self):
60
+ key = CaseKey({"intermediate": 2048})
61
+ with pytest.raises(TypeError, match="immutable"):
62
+ key["intermediate"] = 4096
63
+ with pytest.raises(TypeError, match="immutable"):
64
+ del key["intermediate"]
65
+ with pytest.raises(TypeError, match="immutable"):
66
+ key.update({"numtokens": 256})
67
+ with pytest.raises(TypeError, match="immutable"):
68
+ key.clear()
tests/kernels/helion/test_config_manager.py
+85
-42
@@ -23,6 +23,7 @@ if not has_helion():
23
24
import helion
25
26
+from vllm.kernels.helion.case_key import CaseKey
27
from vllm.kernels.helion.config_manager import (
28
ConfigManager,
29
ConfigSet,
@@ -49,22 +50,25 @@ class TestConfigSet:
50
51
def test_config_set_from_dict(self):
52
"""Test creating ConfigSet from dictionary data."""
52
- # Use realistic config data that helion.Config can handle
53
config_data = {
54
"block_sizes": [32, 16],
55
"num_warps": 4,
56
"num_stages": 3,
57
"pid_type": "persistent_interleaved",
58
}
59
- data = {"h100": {"batch_32_hidden_4096": config_data}}
59
+ data = {
60
+ "h100": [
61
+ {"key": {"batch": 32, "hidden": 4096}, "config": config_data},
62
+ ]
63
+ }
64
65
config_set = ConfigSet.from_dict("test_kernel", data)
66
67
assert config_set.kernel_name == "test_kernel"
68
assert config_set.get_platforms() == ["h100"]
69
66
- # Verify the config was created correctly
67
- config = config_set.get_config("h100", "batch_32_hidden_4096")
70
+ internal_key = CaseKey({"batch": 32, "hidden": 4096})
71
+ config = config_set.get_config("h100", internal_key)
72
assert isinstance(config, helion.Config)
73
assert config.block_sizes == [32, 16]
74
assert config.num_warps == 4
@@ -76,17 +80,19 @@ class TestConfigSet:
80
config_set = ConfigSet("test_kernel")
81
82
with pytest.raises(KeyError, match="platform 'h100' not found"):
79
- config_set.get_config("h100", "batch_32_hidden_4096")
83
+ config_set.get_config("h100", "nonexistent")
84
81
- # Use realistic config data
85
config_data = {"num_warps": 8, "num_stages": 4}
83
- data = {"h100": {"batch_64_hidden_2048": config_data}}
86
+ data = {
87
+ "h100": [
88
+ {"key": {"batch": 64, "hidden": 2048}, "config": config_data},
89
+ ]
90
+ }
91
config_set = ConfigSet.from_dict("test_kernel", data)
92
86
- with pytest.raises(
87
- KeyError, match="config_key 'batch_32_hidden_4096' not found"
88
- ):
89
- config_set.get_config("h100", "batch_32_hidden_4096")
93
+ nonexistent_key = CaseKey({"batch": 32, "hidden": 4096})
94
+ with pytest.raises(KeyError, match="config_key .* not found"):
95
+ config_set.get_config("h100", nonexistent_key)
96
97
def test_config_set_get_platforms(self):
98
"""Test get_platforms method."""
@@ -95,8 +101,12 @@ class TestConfigSet:
101
config2 = {"num_warps": 8, "num_stages": 5}
102
103
data = {
98
- "h100": {"batch_32_hidden_4096": config1},
99
- "a100": {"batch_16_hidden_2048": config2},
104
+ "h100": [
105
+ {"key": {"batch": 32, "hidden": 4096}, "config": config1},
106
+ ],
107
+ "a100": [
108
+ {"key": {"batch": 16, "hidden": 2048}, "config": config2},
109
+ ],
110
}
111
config_set = ConfigSet.from_dict("test_kernel", data)
112
@@ -105,39 +115,49 @@ class TestConfigSet:
115
116
def test_config_set_get_config_keys(self):
117
"""Test get_config_keys method."""
108
- # Use realistic config data
118
config1 = {"num_warps": 4, "num_stages": 3}
119
config2 = {"num_warps": 8, "num_stages": 5}
120
121
data = {
113
- "h100": {
114
- "batch_32_hidden_4096": config1,
115
- "batch_64_hidden_2048": config2,
116
- }
122
+ "h100": [
123
+ {"key": {"batch": 32, "hidden": 4096}, "config": config1},
124
+ {"key": {"batch": 64, "hidden": 2048}, "config": config2},
125
+ ]
126
}
127
config_set = ConfigSet.from_dict("test_kernel", data)
128
129
config_keys = config_set.get_config_keys("h100")
121
- assert config_keys == ["batch_32_hidden_4096", "batch_64_hidden_2048"]
130
+ expected_keys = sorted(
131
+ [
132
+ CaseKey({"batch": 32, "hidden": 4096}),
133
+ CaseKey({"batch": 64, "hidden": 2048}),
134
+ ],
135
+ key=lambda k: str(k) if k is not None else "",
136
+ )
137
+ assert config_keys == expected_keys
138
139
assert config_set.get_config_keys("v100") == []
140
141
def test_config_set_to_dict(self):
142
"""Test converting ConfigSet to dictionary."""
127
- # Use realistic config data
143
original_config = {
144
"block_sizes": [64, 32],
145
"num_warps": 16,
146
"num_stages": 4,
147
"pid_type": "persistent_blocked",
148
}
134
- original_data = {"h100": {"batch_32_hidden_4096": original_config}}
149
+ original_data = {
150
+ "h100": [
151
+ {"key": {"batch": 32, "hidden": 4096}, "config": original_config},
152
+ ]
153
+ }
154
155
config_set = ConfigSet.from_dict("test_kernel", original_data)
156
result_data = config_set.to_dict()
157
139
- # The result should match the original (Config roundtrip should work)
140
- assert result_data == original_data
158
+ internal_key = CaseKey({"batch": 32, "hidden": 4096})
159
+ assert internal_key in result_data["h100"]
160
+ assert result_data["h100"][internal_key] == original_config
161
162
163
class TestConfigManager:
@@ -202,7 +222,10 @@ class TestConfigManager:
222
kernel_dir.mkdir()
223
platform_file = kernel_dir / "h100.json"
224
with open(platform_file, "w") as f:
205
- json.dump({"batch_32_hidden_4096": kernel_config}, f)
225
+ json.dump(
226
+ [{"key": {"batch": 32, "hidden": 4096}, "config": kernel_config}],
227
+ f,
228
+ )
229
230
manager = ConfigManager(base_dir=temp_dir)
231
config_set = manager.load_config_set("test_kernel")
@@ -211,7 +234,8 @@ class TestConfigManager:
234
assert config_set.kernel_name == "test_kernel"
235
assert config_set.get_platforms() == ["h100"]
236
214
- config = config_set.get_config("h100", "batch_32_hidden_4096")
237
+ internal_key = CaseKey({"batch": 32, "hidden": 4096})
238
+ config = config_set.get_config("h100", internal_key)
239
assert isinstance(config, helion.Config)
240
assert config.block_sizes == [128, 64]
241
assert config.num_warps == 8
@@ -241,7 +265,11 @@ class TestConfigManager:
265
"num_stages": 8,
266
"pid_type": "persistent_blocked",
267
}
244
- data = {"h100": {"batch_32_hidden_4096": kernel_config}}
268
+ data = {
269
+ "h100": [
270
+ {"key": {"batch": 32, "hidden": 4096}, "config": kernel_config},
271
+ ]
272
+ }
273
config_set = ConfigSet.from_dict("test_kernel", data)
274
275
manager = ConfigManager(base_dir=temp_dir)
@@ -255,13 +283,21 @@ class TestConfigManager:
283
assert platform_file.exists()
284
with open(platform_file) as f:
285
loaded_data = json.load(f)
258
- assert loaded_data == data["h100"]
286
+ assert isinstance(loaded_data, list)
287
+ assert len(loaded_data) == 1
288
+ entry = loaded_data[0]
289
+ assert entry["key"] == {"batch": 32, "hidden": 4096}
290
+ assert entry["config"] == kernel_config
291
292
def test_save_config_set_creates_directory(self):
293
"""Test that save_config_set creates parent directories if needed."""
294
with tempfile.TemporaryDirectory() as temp_dir:
295
nested_dir = Path(temp_dir) / "nested" / "configs"
264
- data = {"h100": {"default": {"num_warps": 4}}}
296
+ data = {
297
+ "h100": [
298
+ {"key": {}, "config": {"num_warps": 4}},
299
+ ]
300
+ }
301
config_set = ConfigSet.from_dict("test_kernel", data)
302
303
manager = ConfigManager(base_dir=nested_dir)
@@ -288,34 +324,41 @@ class TestConfigManager:
324
kernel_dir.mkdir()
325
with open(kernel_dir / "h100.json", "w") as f:
326
json.dump(
291
- {
292
- "batch_32_hidden_4096": config_1,
293
- "batch_64_hidden_2048": config_2,
294
- "default": default_config,
295
- },
327
+ [
328
+ {"key": {"batch": 32, "hidden": 4096}, "config": config_1},
329
+ {"key": {"batch": 64, "hidden": 2048}, "config": config_2},
330
+ {"key": {}, "config": default_config},
331
+ ],
332
f,
333
)
334
with open(kernel_dir / "a100.json", "w") as f:
299
- json.dump({"batch_16_hidden_1024": config_3}, f)
335
+ json.dump(
336
+ [{"key": {"batch": 16, "hidden": 1024}, "config": config_3}],
337
+ f,
338
+ )
339
340
manager = ConfigManager(base_dir=temp_dir)
341
342
+ key_b32_h4096 = CaseKey({"batch": 32, "hidden": 4096})
343
+ key_b64_h2048 = CaseKey({"batch": 64, "hidden": 2048})
344
+ key_b16_h1024 = CaseKey({"batch": 16, "hidden": 1024})
345
+
346
h100_configs = manager.get_platform_configs("test_kernel", "h100")
347
assert len(h100_configs) == 3
305
- assert "batch_32_hidden_4096" in h100_configs
306
- assert "batch_64_hidden_2048" in h100_configs
307
- assert "default" in h100_configs
348
+ assert key_b32_h4096 in h100_configs
349
+ assert key_b64_h2048 in h100_configs
350
+ assert CaseKey.default() in h100_configs
351
for config in h100_configs.values():
352
assert isinstance(config, helion.Config)
353
311
- assert h100_configs["batch_32_hidden_4096"].num_warps == 4
312
- assert h100_configs["default"].num_stages == 7
354
+ assert h100_configs[key_b32_h4096].num_warps == 4
355
+ assert h100_configs[CaseKey.default()].num_stages == 7
356
357
a100_configs = manager.get_platform_configs("test_kernel", "a100")
358
assert len(a100_configs) == 1
316
- assert "batch_16_hidden_1024" in a100_configs
317
- assert isinstance(a100_configs["batch_16_hidden_1024"], helion.Config)
318
- assert a100_configs["batch_16_hidden_1024"].num_warps == 2
359
+ assert key_b16_h1024 in a100_configs
360
+ assert isinstance(a100_configs[key_b16_h1024], helion.Config)
361
+ assert a100_configs[key_b16_h1024].num_warps == 2
362
363
nonexistent_configs = manager.get_platform_configs("test_kernel", "v100")
364
assert len(nonexistent_configs) == 0
tests/kernels/helion/test_register.py
+55
-48
@@ -24,6 +24,7 @@ import helion
24
import helion.language as hl
25
26
from tests.kernels.helion.helpers import dummy_kernel_registry
27
+from vllm.kernels.helion.case_key import CaseKey
28
from vllm.kernels.helion.config_manager import ConfigManager
29
from vllm.kernels.helion.register import (
30
_HOP_AVAILABLE,
@@ -54,22 +55,22 @@ def _add_kernel(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
55
def sample_configs():
56
"""Create real Helion config objects for testing."""
57
return {
57
- "hiddensize_4096_batchsize_32": helion.Config(
58
+ CaseKey({"batchsize": 32, "hiddensize": 4096}): helion.Config(
59
block_sizes=[128],
60
num_warps=4,
61
num_stages=3,
62
),
62
- "hiddensize_4096_batchsize_64": helion.Config(
63
+ CaseKey({"batchsize": 64, "hiddensize": 4096}): helion.Config(
64
block_sizes=[256],
65
num_warps=8,
66
num_stages=4,
67
),
67
- "hiddensize_4096_batchsize_128": helion.Config(
68
+ CaseKey({"batchsize": 128, "hiddensize": 4096}): helion.Config(
69
block_sizes=[512],
70
num_warps=16,
71
num_stages=2,
72
),
72
- "default": helion.Config(
73
+ CaseKey.default(): helion.Config(
74
block_sizes=[64],
75
num_warps=2,
76
num_stages=2,
@@ -101,8 +102,7 @@ def configured_kernel(sample_kernel, sample_configs, config_manager_with_test_co
102
"""Create a ConfiguredHelionKernel for testing."""
103
104
def test_config_picker(args, config_keys):
104
- """Simple config picker that returns default."""
105
- return "default"
105
+ return None
106
107
with (
108
patch(
@@ -115,7 +115,6 @@ def configured_kernel(sample_kernel, sample_configs, config_manager_with_test_co
115
),
116
patch("vllm.kernels.helion.register.helion.kernel") as mock_kernel,
117
):
118
- # Mock just the helion.kernel decorator to avoid actual kernel compilation
118
mock_decorated = Mock()
119
mock_kernel.return_value = Mock(return_value=mock_decorated)
120
@@ -199,7 +198,9 @@ class TestConfiguredHelionKernel:
198
199
def test_init_raises_without_picker(self, sample_kernel, sample_configs):
200
"""Test that __init__ raises when no picker registered."""
202
- configs = {"default": sample_configs["default"]}
201
+ configs: dict[CaseKey, helion.Config] = {
202
+ CaseKey.default(): sample_configs[CaseKey.default()]
203
+ }
204
mock_config_manager = Mock(spec=ConfigManager)
205
mock_config_manager.get_platform_configs = Mock(return_value=configs)
206
@@ -227,7 +228,7 @@ class TestConfiguredHelionKernel:
228
"""Test that config selector validates picker returns valid key."""
229
230
def invalid_picker(args, config_keys):
230
- return "invalid_key"
231
+ return {"invalid": 999}
232
233
kernel = create_configured_kernel_with_configs(
234
op_name="test_kernel",
@@ -263,7 +264,7 @@ class TestConfiguredHelionKernel:
264
selector = kernel._create_config_selector(key_computer)
265
266
result = selector((torch.randn(32, 4096),))
266
- assert result is kernel.configs["default"]
267
+ assert result is kernel.configs[CaseKey.default()]
268
269
def test_create_decorated_kernel_passes_helion_settings(
270
self, sample_kernel, sample_configs
@@ -271,7 +272,7 @@ class TestConfiguredHelionKernel:
272
"""Test that _create_decorated_kernel passes helion_settings."""
273
274
def default_picker(args, config_keys):
274
- return "default"
275
+ return None
276
277
settings = helion.Settings()
278
settings.print_output_code = True
@@ -315,10 +316,10 @@ class TestConfiguredHelionKernel:
316
x = args[0]
317
batch_size = x.shape[0]
318
if batch_size <= 32:
318
- return "hiddensize_4096_batchsize_32"
319
+ return CaseKey({"batchsize": 32, "hiddensize": 4096})
320
elif batch_size <= 64:
320
- return "hiddensize_4096_batchsize_64"
321
- return "hiddensize_4096_batchsize_128"
321
+ return CaseKey({"batchsize": 64, "hiddensize": 4096})
322
+ return CaseKey({"batchsize": 128, "hiddensize": 4096})
323
324
mock_config_manager = Mock(spec=ConfigManager)
325
mock_config_manager.get_platform_configs = Mock(return_value=sample_configs)
@@ -350,13 +351,13 @@ class TestConfiguredHelionKernel:
351
352
tensor = torch.randn(50, 4096) # batch=50, should select batchsize_64
353
353
- # key receives unpacked args, autotuner receives args as tuple
354
key_result = key_fn(tensor)
355
autotuner = autotuner_fn(None, (tensor,))
356
config = autotuner.autotune()
357
358
- assert key_result == "hiddensize_4096_batchsize_64"
359
- assert config is kernel.configs["hiddensize_4096_batchsize_64"]
358
+ expected_key = CaseKey({"batchsize": 64, "hiddensize": 4096})
359
+ assert key_result == str(expected_key)
360
+ assert config is kernel.configs[expected_key]
361
362
363
class TestHelionKernelWrapper:
@@ -369,7 +370,7 @@ class TestHelionKernelWrapper:
370
return torch.zeros_like(args[0])
371
372
def default_picker(args, config_keys):
372
- return "default"
373
+ return None
374
375
mock_config_manager = Mock(spec=ConfigManager)
376
mock_config_manager.get_platform_configs = Mock(
@@ -406,7 +407,7 @@ class TestHelionKernelWrapper:
407
return torch.zeros_like(args[0])
408
409
def default_picker(args, config_keys):
409
- return "default"
410
+ return None
411
412
mock_config_manager = Mock(spec=ConfigManager)
413
mock_config_manager.get_platform_configs = Mock(return_value={})
@@ -441,7 +442,7 @@ class TestHelionKernelWrapper:
442
return torch.zeros_like(args[0])
443
444
def default_picker(args, config_keys):
444
- return "default"
445
+ return None
446
447
mock_config_manager = Mock(spec=ConfigManager)
448
mock_config_manager.get_platform_configs = Mock(return_value={})
@@ -476,7 +477,7 @@ class TestHelionKernelWrapper:
477
return torch.zeros_like(args[0])
478
479
def default_picker(args, config_keys):
479
- return "default"
480
+ return None
481
482
expected_inputs = {"key1": (torch.randn(4),)}
483
input_gen = Mock(return_value=expected_inputs)
@@ -516,7 +517,7 @@ class TestHelionKernelWrapper:
517
return torch.zeros_like(args[0])
518
519
def default_picker(args, config_keys):
519
- return "default"
520
+ return None
521
522
mock_config_manager = Mock(spec=ConfigManager)
523
mock_config_manager.get_platform_configs = Mock(return_value={})
@@ -563,7 +564,7 @@ class TestHelionKernelWrapper:
564
return torch.zeros_like(args[0])
565
566
def default_picker(args, config_keys):
566
- return "default"
567
+ return None
568
569
mock_config_manager = Mock(spec=ConfigManager)
570
mock_config_manager.get_platform_configs = Mock(return_value=sample_configs)
@@ -601,7 +602,9 @@ class TestHelionKernelWrapper:
602
on the HOP path (no custom op registration needed)."""
603
from vllm.kernels.helion.utils import get_canonical_gpu_name
604
604
- configs = {"default": helion.Config(block_sizes=[4, 4])}
605
+ configs: dict[CaseKey, helion.Config] = {
606
+ CaseKey.default(): helion.Config(block_sizes=[4, 4])
607
+ }
608
with (
609
dummy_kernel_registry(configs=configs) as register,
610
patch(
@@ -610,7 +613,7 @@ class TestHelionKernelWrapper:
613
) as mock_gpu,
614
):
615
wrapper = register(
613
- config_picker=lambda args, keys: "default",
616
+ config_picker=lambda args, keys: None,
617
)(_add_kernel)
618
619
mock_gpu.assert_called_once()
@@ -642,7 +645,7 @@ class TestHelionKernelWrapper:
645
) as mock_gpu,
646
):
647
wrapper = register(
645
- config_picker=lambda args, keys: "default",
648
+ config_picker=lambda args, keys: None,
649
)(_add_kernel)
650
651
# Init must have detected GPU and built the kernel
@@ -660,7 +663,7 @@ class TestHelionKernelWrapper:
663
return torch.zeros_like(args[0])
664
665
def default_picker(args, config_keys):
663
- return "default"
666
+ return None
667
668
mock_config_manager = Mock(spec=ConfigManager)
669
mock_config_manager.get_platform_configs = Mock(return_value=sample_configs)
@@ -703,7 +706,7 @@ class TestHelionKernelWrapper:
706
return torch.zeros_like(args[0])
707
708
def default_picker(args, config_keys):
706
- return "default"
709
+ return None
710
711
mock_config_manager = Mock(spec=ConfigManager)
712
mock_config_manager.get_platform_configs = Mock(return_value=sample_configs)
@@ -784,9 +787,9 @@ class TestKernelRegistry:
787
def test_get_kernel_by_name_returns_kernel(self):
788
"""Test get_kernel_by_name returns registered kernel."""
789
with dummy_kernel_registry() as register:
787
- wrapper = register(
788
- "test_kernel", config_picker=lambda args, keys: "default"
789
- )(_add_kernel)
790
+ wrapper = register("test_kernel", config_picker=lambda args, keys: None)(
791
+ _add_kernel
792
+ )
793
794
from vllm.kernels.helion.register import _REGISTERED_KERNELS
795
@@ -809,7 +812,7 @@ class TestKernelRegistry:
812
mock_fake = Mock()
813
mock_infer.return_value = mock_fake
814
wrapper = register(
812
- config_picker=lambda args, keys: "default",
815
+ config_picker=lambda args, keys: None,
816
)(_add_kernel)
817
818
mock_infer.assert_called_once_with(_add_kernel, None)
@@ -818,7 +821,7 @@ class TestKernelRegistry:
821
def test_register_kernel_creates_wrapper(self):
822
"""Test register_kernel creates HelionKernelWrapper."""
823
with dummy_kernel_registry() as register:
821
- result = register("test_name", config_picker=lambda args, keys: "default")(
824
+ result = register("test_name", config_picker=lambda args, keys: None)(
825
_add_kernel
826
)
827
@@ -829,16 +832,16 @@ class TestKernelRegistry:
832
def test_register_kernel_auto_detects_name(self):
833
"""Test register_kernel uses function name when no name provided."""
834
with dummy_kernel_registry() as register:
832
- wrapper = register(config_picker=lambda args, keys: "default")(_add_kernel)
835
+ wrapper = register(config_picker=lambda args, keys: None)(_add_kernel)
836
837
assert wrapper.op_name == "_add_kernel"
838
839
def test_register_kernel_registers_in_global_registry(self):
840
"""Test register_kernel adds wrapper to global registry."""
841
with dummy_kernel_registry() as register:
839
- wrapper = register(
840
- "test_kernel", config_picker=lambda args, keys: "default"
841
- )(_add_kernel)
842
+ wrapper = register("test_kernel", config_picker=lambda args, keys: None)(
843
+ _add_kernel
844
+ )
845
846
registered_kernels = get_registered_kernels()
847
assert "test_kernel" in registered_kernels
@@ -852,7 +855,7 @@ class TestKernelRegistry:
855
with dummy_kernel_registry() as register:
856
result = register(
857
"test_name",
855
- config_picker=lambda args, keys: "default",
858
+ config_picker=lambda args, keys: None,
859
helion_settings=settings,
860
)(_add_kernel)
861
@@ -865,7 +868,7 @@ class TestKernelRegistry:
868
with dummy_kernel_registry() as register:
869
result = register(
870
"custom_name",
868
- config_picker=lambda args, keys: "default",
871
+ config_picker=lambda args, keys: None,
872
fake_impl=mock_fake,
873
)(_add_kernel)
874
@@ -875,12 +878,12 @@ class TestKernelRegistry:
878
def test_register_kernel_raises_on_duplicate_registration(self):
879
"""Test register_kernel raises error on duplicate names."""
880
with dummy_kernel_registry() as register:
878
- register("duplicate_name", config_picker=lambda args, keys: "default")(
881
+ register("duplicate_name", config_picker=lambda args, keys: None)(
882
_add_kernel
883
)
884
885
with pytest.raises(ValueError, match="already registered"):
883
- register("duplicate_name", config_picker=lambda args, keys: "default")(
886
+ register("duplicate_name", config_picker=lambda args, keys: None)(
887
_add_kernel
888
)
889
@@ -893,7 +896,7 @@ class TestKernelRegistry:
896
897
@register_kernel(
898
"test",
896
- config_picker=lambda args, keys: "default",
899
+ config_picker=lambda args, keys: None,
900
helion_settings=mock_settings,
901
)
902
def test_kernel(x):
@@ -910,7 +913,7 @@ class TestKernelRegistry:
913
):
914
register(
915
"test",
913
- config_picker=lambda args, keys: "default",
916
+ config_picker=lambda args, keys: None,
917
helion_settings=mock_settings,
918
)(_add_kernel)
919
@@ -940,7 +943,7 @@ class TestKernelRegistry:
943
944
wrapper = register_kernel(
945
"disabled_kernel",
943
- config_picker=lambda args, keys: "default",
946
+ config_picker=lambda args, keys: None,
947
fake_impl=fake_impl,
948
)(_add_kernel)
949
@@ -957,12 +960,14 @@ class TestTorchCompileHOP:
960
def test_compiled_graph_contains_helion_hop(self):
961
"""Verify torch.compile on a HelionKernelWrapper emits a
962
helion_kernel_wrapper_mutation HOP node in the FX graph."""
960
- configs = {"default": helion.Config(block_sizes=[4, 4])}
963
+ configs: dict[CaseKey, helion.Config] = {
964
+ CaseKey.default(): helion.Config(block_sizes=[4, 4])
965
+ }
966
967
with dummy_kernel_registry(configs=configs) as register:
968
add_helion_kernel = register(
969
op_name="test_torch_compile_add_kernel",
965
- config_picker=lambda args, keys: "default",
970
+ config_picker=lambda args, keys: None,
971
)(_add_kernel)
972
973
captured_graph: torch.fx.GraphModule | None = None
@@ -1013,12 +1018,14 @@ class TestTorchCompileHOP:
1018
def test_inductor_backend_compiles_helion_hop(self):
1019
"""Test torch.compile with inductor backend and Helion fusion enabled."""
1020
1016
- configs = {"default": helion.Config(block_sizes=[4, 4])}
1021
+ configs: dict[CaseKey, helion.Config] = {
1022
+ CaseKey.default(): helion.Config(block_sizes=[4, 4])
1023
+ }
1024
1025
with dummy_kernel_registry(configs=configs) as register:
1026
add_helion_kernel = register(
1027
op_name="test_inductor_add_kernel",
1021
- config_picker=lambda args, keys: "default",
1028
+ config_picker=lambda args, keys: None,
1029
helion_settings=helion.Settings(
1030
torch_compile_fusion=True, static_shapes=False
1031
),
tests/kernels/helion/test_silu_mul_fp8.py
+32
-63
@@ -13,8 +13,10 @@ if not has_helion():
13
allow_module_level=True,
14
)
15
16
+from vllm.kernels.helion.case_key import CaseKey
17
from vllm.kernels.helion.config_manager import ConfigManager
18
from vllm.kernels.helion.ops.silu_mul_fp8 import (
19
+ _pick_cache,
20
pick_silu_mul_fp8_config,
21
silu_mul_fp8,
22
silu_mul_fp8_baseline,
@@ -52,10 +54,13 @@ def reset_config_manager_singleton():
54
55
56
class TestSiluMulFp8ConfigPicker:
57
+ def setup_method(self):
58
+ _pick_cache.clear()
59
+
60
def test_config_picker_exact_match(self):
61
config_keys = [
57
- "intermediate_2048_numtokens_256",
58
- "intermediate_4096_numtokens_256",
62
+ CaseKey({"intermediate": 2048, "numtokens": 256}),
63
+ CaseKey({"intermediate": 4096, "numtokens": 256}),
64
]
65
66
input_tensor = torch.randn(32, 4096, dtype=torch.bfloat16, device="cuda")
@@ -63,33 +68,22 @@ class TestSiluMulFp8ConfigPicker:
68
args = (input_tensor, scale)
69
70
selected_key = pick_silu_mul_fp8_config(args, config_keys)
66
- assert selected_key == "intermediate_2048_numtokens_256"
71
+ assert selected_key == CaseKey({"intermediate": 2048, "numtokens": 256})
72
73
def test_config_picker_closest_match(self):
74
config_keys = [
70
- "intermediate_2048_numtokens_256",
71
- "intermediate_4096_numtokens_256",
75
+ CaseKey({"intermediate": 2048, "numtokens": 256}),
76
+ CaseKey({"intermediate": 4096, "numtokens": 256}),
77
]
73
- # Use 7000 (intermediate_size=3500) which is closer to 4096 than 2048
78
input_tensor = torch.randn(32, 7000, dtype=torch.bfloat16, device="cuda")
79
scale = torch.tensor([0.5], dtype=torch.float32, device="cuda")
80
args = (input_tensor, scale)
81
82
selected_key = pick_silu_mul_fp8_config(args, config_keys)
79
- assert selected_key == "intermediate_4096_numtokens_256"
80
-
81
- def test_config_picker_fallback_to_default(self):
82
- config_keys = ["default"]
83
-
84
- input_tensor = torch.randn(32, 4096, dtype=torch.bfloat16, device="cuda")
85
- scale = torch.tensor([0.5], dtype=torch.float32, device="cuda")
86
- args = (input_tensor, scale)
87
-
88
- selected_key = pick_silu_mul_fp8_config(args, config_keys)
89
- assert selected_key == "default"
83
+ assert selected_key == CaseKey({"intermediate": 4096, "numtokens": 256})
84
85
def test_config_picker_no_configs(self):
92
- config_keys: list[str] = []
86
+ config_keys: list[dict] = []
87
88
input_tensor = torch.randn(32, 4096, dtype=torch.bfloat16, device="cuda")
89
scale = torch.tensor([0.5], dtype=torch.float32, device="cuda")
@@ -101,9 +95,9 @@ class TestSiluMulFp8ConfigPicker:
95
@pytest.mark.parametrize("intermediate_size", [2048, 4096, 5120])
96
def test_config_picker_different_sizes(self, intermediate_size):
97
config_keys = [
104
- "intermediate_2048_numtokens_256",
105
- "intermediate_4096_numtokens_256",
106
- "intermediate_5120_numtokens_256",
98
+ CaseKey({"intermediate": 2048, "numtokens": 256}),
99
+ CaseKey({"intermediate": 4096, "numtokens": 256}),
100
+ CaseKey({"intermediate": 5120, "numtokens": 256}),
101
]
102
103
input_tensor = torch.randn(
@@ -113,72 +107,47 @@ class TestSiluMulFp8ConfigPicker:
107
args = (input_tensor, scale)
108
109
selected_key = pick_silu_mul_fp8_config(args, config_keys)
116
- expected_key = f"intermediate_{intermediate_size}_numtokens_256"
117
- assert selected_key == expected_key
110
+ assert selected_key == {
111
+ "intermediate": intermediate_size,
112
+ "numtokens": 256,
113
+ }
114
115
def test_config_picker_numtokens_ceiling(self):
120
- """Pick the smallest numtokens >= input num_tokens."""
116
config_keys = [
122
- "intermediate_4096_numtokens_8",
123
- "intermediate_4096_numtokens_32",
124
- "intermediate_4096_numtokens_128",
125
- "intermediate_4096_numtokens_256",
117
+ CaseKey({"intermediate": 4096, "numtokens": 8}),
118
+ CaseKey({"intermediate": 4096, "numtokens": 32}),
119
+ CaseKey({"intermediate": 4096, "numtokens": 128}),
120
+ CaseKey({"intermediate": 4096, "numtokens": 256}),
121
]
127
- # 20 tokens -> should pick numtokens_32 (smallest >= 20)
122
input_tensor = torch.randn(20, 8192, dtype=torch.bfloat16, device="cuda")
123
scale = torch.tensor([0.5], dtype=torch.float32, device="cuda")
124
125
selected_key = pick_silu_mul_fp8_config((input_tensor, scale), config_keys)
132
- assert selected_key == "intermediate_4096_numtokens_32"
126
+ assert selected_key == CaseKey({"intermediate": 4096, "numtokens": 32})
127
128
def test_config_picker_numtokens_exact(self):
135
- """Exact num_tokens match is preferred over ceiling."""
129
config_keys = [
137
- "intermediate_4096_numtokens_8",
138
- "intermediate_4096_numtokens_32",
139
- "intermediate_4096_numtokens_128",
130
+ CaseKey({"intermediate": 4096, "numtokens": 8}),
131
+ CaseKey({"intermediate": 4096, "numtokens": 32}),
132
+ CaseKey({"intermediate": 4096, "numtokens": 128}),
133
]
134
input_tensor = torch.randn(32, 8192, dtype=torch.bfloat16, device="cuda")
135
scale = torch.tensor([0.5], dtype=torch.float32, device="cuda")
136
137
selected_key = pick_silu_mul_fp8_config((input_tensor, scale), config_keys)
145
- assert selected_key == "intermediate_4096_numtokens_32"
138
+ assert selected_key == CaseKey({"intermediate": 4096, "numtokens": 32})
139
140
def test_config_picker_numtokens_fallback_to_largest(self):
148
- """Fall back to the largest numtokens when input exceeds all."""
141
config_keys = [
150
- "intermediate_4096_numtokens_8",
151
- "intermediate_4096_numtokens_32",
152
- "intermediate_4096_numtokens_128",
142
+ CaseKey({"intermediate": 4096, "numtokens": 8}),
143
+ CaseKey({"intermediate": 4096, "numtokens": 32}),
144
+ CaseKey({"intermediate": 4096, "numtokens": 128}),
145
]
154
- # 512 tokens -> exceeds all available, should pick largest (128)
146
input_tensor = torch.randn(512, 8192, dtype=torch.bfloat16, device="cuda")
147
scale = torch.tensor([0.5], dtype=torch.float32, device="cuda")
148
149
selected_key = pick_silu_mul_fp8_config((input_tensor, scale), config_keys)
159
- assert selected_key == "intermediate_4096_numtokens_128"
160
-
161
- def test_config_picker_malformed_key_raises(self):
162
- """Malformed config keys should raise ValueError."""
163
- config_keys = ["intermediate_4096_badformat_256"]
164
- input_tensor = torch.randn(32, 8192, dtype=torch.bfloat16, device="cuda")
165
- scale = torch.tensor([0.5], dtype=torch.float32, device="cuda")
166
-
167
- with pytest.raises(ValueError, match="Malformed config key"):
168
- pick_silu_mul_fp8_config((input_tensor, scale), config_keys)
169
-
170
- def test_config_picker_default_ignored_when_valid_keys_exist(self):
171
- """'default' is skipped in favor of a real match."""
172
- config_keys = [
173
- "default",
174
- "intermediate_4096_numtokens_32",
175
- "intermediate_4096_numtokens_128",
176
- ]
177
- input_tensor = torch.randn(64, 8192, dtype=torch.bfloat16, device="cuda")
178
- scale = torch.tensor([0.5], dtype=torch.float32, device="cuda")
179
-
180
- selected_key = pick_silu_mul_fp8_config((input_tensor, scale), config_keys)
181
- assert selected_key == "intermediate_4096_numtokens_128"
150
+ assert selected_key == CaseKey({"intermediate": 4096, "numtokens": 128})
151
152
153
class TestSiluMulFp8Correctness:
vllm/kernels/helion/__init__.py
+4
@@ -3,11 +3,13 @@
3
"""Helion integration for vLLM."""
4
5
import vllm.kernels.helion.ops # noqa: F401 Auto-register all Helion ops
6
+from vllm.kernels.helion.case_key import CaseKey
7
from vllm.kernels.helion.config_manager import (
8
ConfigManager,
9
ConfigSet,
10
)
11
from vllm.kernels.helion.register import (
12
+ ConfigPicker,
13
ConfiguredHelionKernel,
14
HelionKernelWrapper,
15
get_kernel_by_name,
@@ -19,9 +21,11 @@ from vllm.kernels.helion.utils import canonicalize_gpu_name, get_canonical_gpu_n
21
22
__all__ = [
23
# Config management
24
+ "CaseKey",
25
"ConfigManager",
26
"ConfigSet",
27
# Kernel registration
28
+ "ConfigPicker",
29
"ConfiguredHelionKernel",
30
"HelionKernelWrapper",
31
"get_kernel_by_name",
vllm/kernels/helion/case_key.py
new
+72
@@ -0,0 +1,72 @@
1
+# SPDX-License-Identifier: Apache-2.0
2
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
3
+"""
4
+Structured key for identifying kernel config/autotune/benchmark cases.
5
+"""
6
+
7
+from __future__ import annotations
8
+
9
+import json
10
+from typing import Any
11
+
12
+
13
+class CaseKey(dict[str, Any]):
14
+ """Immutable, hashable dict for identifying kernel cases.
15
+
16
+ Used as the key for config lookup, autotuning, benchmarking, and
17
+ input generation. Behaves like a read-only dict and can be used
18
+ as a dict key or in sets.
19
+
20
+ The canonical string form (``__str__``) is stable JSON with sorted
21
+ keys. Use ``CaseKey.default()`` for the default/fallback key.
22
+ The regular constructor requires at least one key-value pair::
23
+
24
+ CaseKey({"intermediate": 2048, "numtokens": 256})
25
+ CaseKey.default() # default/fallback
26
+ """
27
+
28
+ def __init__(self, *args: Any, _allow_empty: bool = False, **kwargs: Any):
29
+ super().__init__(*args, **kwargs)
30
+ if not self and not _allow_empty:
31
+ raise TypeError(
32
+ "CaseKey requires at least one key-value pair. "
33
+ "Use CaseKey.default() for the default config key."
34
+ )
35
+ self._str: str | None = None
36
+ self._hash: int | None = None
37
+
38
+ @classmethod
39
+ def default(cls) -> CaseKey:
40
+ """Create a default case key (empty)."""
41
+ return cls(_allow_empty=True)
42
+
43
+ def __hash__(self) -> int: # type: ignore[override]
44
+ if self._hash is None:
45
+ self._hash = hash(str(self))
46
+ return self._hash
47
+
48
+ def __str__(self) -> str:
49
+ if self._str is None:
50
+ self._str = json.dumps(dict(self), sort_keys=True, separators=(",", ":"))
51
+ return self._str
52
+
53
+ def __repr__(self) -> str:
54
+ if not self:
55
+ return "CaseKey.default()"
56
+ return f"CaseKey({dict(self)})"
57
+
58
+ def is_default(self) -> bool:
59
+ """Return True if this is the default case key (empty)."""
60
+ return not self
61
+
62
+ def _readonly(self, *args: Any, **kwargs: Any) -> Any:
63
+ raise TypeError("CaseKey is immutable")
64
+
65
+ __setitem__ = _readonly # type: ignore[assignment]
66
+ __delitem__ = _readonly # type: ignore[assignment]
67
+ __ior__ = _readonly # type: ignore[assignment]
68
+ update = _readonly # type: ignore[assignment]
69
+ pop = _readonly # type: ignore[assignment]
70
+ popitem = _readonly # type: ignore[assignment]
71
+ setdefault = _readonly # type: ignore[assignment]
72
+ clear = _readonly # type: ignore[assignment]
vllm/kernels/helion/config_manager.py
+93
-59
@@ -11,25 +11,25 @@ Config File Structure
11
Each kernel has a directory: {kernel_name}/
12
Inside, each GPU platform has its own JSON file: {kernel_name}/{platform}.json
13
14
-For example:
15
- silu_mul_fp8/
16
- nvidia_h100.json # { "default": {...}, "batch_32_hidden_4096": {...} }
17
- nvidia_h200.json # { "batch_16_hidden_2048": {...} }
18
-
19
-Each platform file maps config keys to Helion config objects.
20
-Config keys should be structured strings that encode the relevant
21
-parameters (e.g., "batch_32_hidden_4096", "seq_512_heads_16", "fp8_batch_64", etc.).
22
-
23
-Classes
24
--------
25
-- ConfigSet: In-memory collection of configs for a kernel with lookup/query APIs.
26
-- ConfigManager: File-level operations for config persistence.
14
+Platform files store config entries as a JSON array::
15
+
16
+ [
17
+ {"key": {}, "config": {...}},
18
+ {"key": {"intermediate": 2048, "numtokens": 256}, "config": {...}},
19
+ ...,
20
+ ]
21
+
22
+Config keys are ``CaseKey`` instances mapping parameter names to
23
+values. The default config uses ``CaseKey.default()``.
24
"""
25
26
+from __future__ import annotations
27
+
28
import json
29
from pathlib import Path
30
from typing import Any
31
32
+from vllm.kernels.helion.case_key import CaseKey
33
from vllm.logger import init_logger
34
from vllm.utils.import_utils import has_helion
35
@@ -45,11 +45,13 @@ logger = init_logger(__name__)
45
46
47
class ConfigSet:
48
- """In-memory collection of Helion configs with lookup/query capabilities."""
48
+ """In-memory collection of Helion configs with lookup/query capabilities.
49
50
- # Type alias for nested config structure:
51
- # platform -> config_key -> helion.Config
52
- _ConfigDict = dict[str, dict[str, "helion.Config"]]
50
+ Configs are stored keyed by ``CaseKey``. The default config
51
+ uses ``CaseKey.default()`` as its key.
52
+ """
53
+
54
+ _ConfigDict = dict[str, dict[CaseKey, "helion.Config"]]
55
56
def __init__(self, kernel_name: str):
57
self._kernel_name = kernel_name
@@ -59,7 +61,7 @@ class ConfigSet:
61
def kernel_name(self) -> str:
62
return self._kernel_name
63
62
- def get_config(self, platform: str, config_key: str) -> helion.Config:
64
+ def get_config(self, platform: str, config_key: CaseKey) -> helion.Config:
65
platform_dict = self._configs.get(platform)
66
if platform_dict is None:
67
avail_platforms = self.get_platforms()
@@ -82,7 +84,8 @@ class ConfigSet:
84
avail_keys = self.get_config_keys(platform)
85
raise KeyError(
86
f"Config not found for kernel '{self._kernel_name}': "
85
- f"config_key '{config_key}' not found for platform '{platform}'. "
87
+ f"config_key '{config_key}' not found for "
88
+ f"platform '{platform}'. "
89
f"Available config_keys: {avail_keys or '(none)'}"
90
)
91
@@ -91,25 +94,34 @@ class ConfigSet:
94
def get_platforms(self) -> list[str]:
95
return sorted(self._configs.keys())
96
94
- def get_config_keys(self, platform: str) -> list[str]:
97
+ def get_config_keys(self, platform: str) -> list[CaseKey]:
98
platform_dict = self._configs.get(platform.lower())
99
if platform_dict is None:
100
return []
98
- return sorted(platform_dict.keys())
99
-
100
- def to_dict(self) -> dict[str, Any]:
101
- result: dict[str, Any] = {}
102
-
103
- for platform, config_keys_dict in self._configs.items():
104
- result[platform] = {}
105
-
106
- for config_key, config in config_keys_dict.items():
107
- result[platform][config_key] = json.loads(config.to_json())
101
+ return sorted(platform_dict.keys(), key=str)
102
+
103
+ def to_config_entries(self) -> dict[str, list[dict[str, Any]]]:
104
+ """Serialize to config entries format for JSON output."""
105
+ result: dict[str, list[dict[str, Any]]] = {}
106
+ for platform, config_dict in self._configs.items():
107
+ pairs: list[dict[str, Any]] = []
108
+ for config_key, config in config_dict.items():
109
+ config_data = json.loads(config.to_json())
110
+ pairs.append({"key": dict(config_key), "config": config_data})
111
+ result[platform] = pairs
112
+ return result
113
114
+ def to_dict(self) -> dict[str, dict[CaseKey, Any]]:
115
+ """Return configs as a nested dict (platform -> key -> config)."""
116
+ result: dict[str, dict[CaseKey, Any]] = {}
117
+ for platform, config_dict in self._configs.items():
118
+ result[platform] = {
119
+ k: json.loads(v.to_json()) for k, v in config_dict.items()
120
+ }
121
return result
122
123
@classmethod
112
- def from_dict(cls, kernel_name: str, data: dict[str, Any]) -> "ConfigSet":
124
+ def from_dict(cls, kernel_name: str, data: dict[str, Any]) -> ConfigSet:
125
config_set = cls(kernel_name)
126
count = 0
127
@@ -117,9 +129,11 @@ class ConfigSet:
129
if platform not in config_set._configs:
130
config_set._configs[platform] = {}
131
120
- for config_key, config_data in platform_data.items():
121
- config = helion.Config(**config_data)
122
- config_set._configs[platform][config_key] = config
132
+ for entry in platform_data:
133
+ raw_key = entry["key"]
134
+ key = CaseKey.default() if not raw_key else CaseKey(raw_key)
135
+ config = helion.Config(**entry["config"])
136
+ config_set._configs[platform][key] = config
137
count += 1
138
139
if count > 0:
@@ -132,7 +146,10 @@ class ConfigSet:
146
return config_set
147
148
def set_config(
135
- self, platform: str, config_key: str, config: "helion.Config"
149
+ self,
150
+ platform: str,
151
+ config_key: CaseKey,
152
+ config: helion.Config,
153
) -> None:
154
platform = platform.lower()
155
if platform not in self._configs:
@@ -145,7 +162,7 @@ class ConfigSet:
162
config_key,
163
)
164
148
- def has_config(self, platform: str, config_key: str) -> bool:
165
+ def has_config(self, platform: str, config_key: CaseKey) -> bool:
166
platform = platform.lower()
167
platform_dict = self._configs.get(platform)
168
if platform_dict is None:
@@ -156,18 +173,18 @@ class ConfigSet:
173
class ConfigManager:
174
"""File-level configuration management for Helion kernels (global singleton)."""
175
159
- _instance: "ConfigManager | None" = None
176
+ _instance: ConfigManager | None = None
177
_instance_base_dir: Path | None = None
178
162
- def __new__(cls, base_dir: str | Path | None = None) -> "ConfigManager":
179
+ def __new__(cls, base_dir: str | Path | None = None) -> ConfigManager:
180
resolved_base_dir = cls._resolve_base_dir(base_dir)
181
182
if cls._instance is not None:
183
if cls._instance_base_dir != resolved_base_dir:
184
raise ValueError(
185
f"ConfigManager singleton already exists with base_dir "
169
- f"'{cls._instance_base_dir}', cannot create with different "
170
- f"base_dir '{resolved_base_dir}'"
186
+ f"'{cls._instance_base_dir}', cannot create with "
187
+ f"different base_dir '{resolved_base_dir}'"
188
)
189
return cls._instance
190
@@ -190,7 +207,7 @@ class ConfigManager:
207
return (Path(__file__).parent / "configs").resolve()
208
209
@classmethod
193
- def get_instance(cls) -> "ConfigManager":
210
+ def get_instance(cls) -> ConfigManager:
211
if cls._instance is None:
212
raise RuntimeError(
213
"ConfigManager instance has not been created. "
@@ -229,16 +246,16 @@ class ConfigManager:
246
f"Config directory '{self._base_dir}' is not writable: {e}"
247
) from e
248
232
- def _load_platform_file(self, kernel_name: str, platform: str) -> dict[str, Any]:
249
+ def _load_platform_file(self, kernel_name: str, platform: str) -> Any:
250
config_path = self.get_config_file_path(kernel_name, platform)
251
if not config_path.exists():
235
- return {}
252
+ return []
253
try:
254
with open(config_path) as f:
255
return json.load(f)
256
except (json.JSONDecodeError, OSError) as e:
257
logger.error("Failed to load config file %s: %s", config_path, e)
241
- return {}
258
+ return []
259
260
def load_config_set(self, kernel_name: str) -> ConfigSet:
261
kernel_dir = self.get_kernel_dir(kernel_name)
@@ -253,32 +270,36 @@ class ConfigManager:
270
platform_data = json.load(f)
271
data[platform] = platform_data
272
except (json.JSONDecodeError, OSError) as e:
256
- logger.error("Failed to load config file %s: %s", platform_file, e)
273
+ logger.error(
274
+ "Failed to load config file %s: %s",
275
+ platform_file,
276
+ e,
277
+ )
278
279
return ConfigSet.from_dict(kernel_name, data)
280
281
def get_platform_configs(
282
self, kernel_name: str, platform: str
262
- ) -> dict[str, helion.Config]:
283
+ ) -> dict[CaseKey, helion.Config]:
284
platform_data = self._load_platform_file(kernel_name, platform)
285
if not platform_data:
286
return {}
287
config_set = ConfigSet.from_dict(kernel_name, {platform: platform_data})
267
- config_keys = config_set.get_config_keys(platform)
288
return {
269
- config_key: config_set.get_config(platform, config_key)
270
- for config_key in config_keys
289
+ k: config_set.get_config(platform, k)
290
+ for k in config_set.get_config_keys(platform)
291
}
292
293
def save_config_set(self, config_set: ConfigSet) -> Path:
294
kernel_dir = self.get_kernel_dir(config_set.kernel_name)
295
kernel_dir.mkdir(parents=True, exist_ok=True)
296
277
- full_data = config_set.to_dict()
278
- for platform, platform_data in full_data.items():
297
+ full_data = config_set.to_config_entries()
298
+ for platform, pairs in full_data.items():
299
platform_path = kernel_dir / f"{platform}.json"
300
with open(platform_path, "w") as f:
281
- json.dump(platform_data, f, indent=2)
301
+ json.dump(pairs, f, indent=2)
302
+ f.write("\n")
303
logger.info("Saved config to: %s", platform_path)
304
305
return kernel_dir
@@ -287,21 +308,34 @@ class ConfigManager:
308
self,
309
kernel_name: str,
310
platform: str,
290
- configs: dict[str, "helion.Config"],
311
+ configs: dict[CaseKey, helion.Config],
312
) -> Path:
313
"""Save configs for a kernel/platform, merging with existing."""
293
- platform_data = self._load_platform_file(kernel_name, platform)
294
- for config_key, config in configs.items():
295
- platform_data[config_key] = json.loads(config.to_json())
314
+ config_set = ConfigSet.from_dict(
315
+ kernel_name,
316
+ {platform: self._load_platform_file(kernel_name, platform)},
317
+ )
318
+ for key, config in configs.items():
319
+ config_set.set_config(platform, key, config)
320
321
+ pairs = config_set.to_config_entries().get(platform, [])
322
platform_path = self.get_config_file_path(kernel_name, platform)
323
platform_path.parent.mkdir(parents=True, exist_ok=True)
324
with open(platform_path, "w") as f:
300
- json.dump(platform_data, f, indent=2)
325
+ json.dump(pairs, f, indent=2)
326
+ f.write("\n")
327
328
logger.info("Saved config to: %s", platform_path)
329
return platform_path
330
305
- def config_exists(self, kernel_name: str, platform: str, config_key: str) -> bool:
331
+ def config_exists(
332
+ self,
333
+ kernel_name: str,
334
+ platform: str,
335
+ config_key: CaseKey,
336
+ ) -> bool:
337
platform_data = self._load_platform_file(kernel_name, platform)
307
- return config_key in platform_data
338
+ if not platform_data:
339
+ return False
340
+ target = dict(config_key)
341
+ return any(entry["key"] == target for entry in platform_data)
vllm/kernels/helion/configs/silu_mul_fp8/nvidia_h100.json
+15666
-13821
@@ -1,13866 +1,15711 @@
1
-{
2
- "intermediate_2048_numtokens_256": {
3
- "block_sizes": [
4
- 64,
5
- 32
6
- ],
7
- "loop_orders": [
8
- [
9
- 0,
10
- 1
11
- ]
12
- ],
13
- "flatten_loops": [
14
- true
15
- ],
16
- "l2_groupings": [
17
- 1
18
- ],
19
- "range_unroll_factors": [
20
- 0
21
- ],
22
- "range_warp_specializes": [],
23
- "range_num_stages": [
24
- 0
25
- ],
26
- "range_multi_buffers": [
27
- null
28
- ],
29
- "range_flattens": [
30
- null
31
- ],
32
- "load_eviction_policies": [
33
- "",
34
- "",
35
- ""
36
- ],
37
- "num_warps": 8,
38
- "num_stages": 1,
39
- "indexing": [
40
- "pointer",
41
- "pointer",
42
- "pointer",
43
- "pointer"
44
- ],
45
- "pid_type": "flat"
46
- },
47
- "intermediate_4096_numtokens_256": {
48
- "block_sizes": [
49
- 256,
50
- 32
51
- ],
52
- "loop_orders": [
53
- [
54
- 0,
55
- 1
56
- ]
57
- ],
58
- "flatten_loops": [
59
- true
60
- ],
61
- "l2_groupings": [
62
- 1
63
- ],
64
- "range_unroll_factors": [
65
- 0
66
- ],
67
- "range_warp_specializes": [],
68
- "range_num_stages": [
69
- 0
70
- ],
71
- "range_multi_buffers": [
72
- null
73
- ],
74
- "range_flattens": [
75
- null
76
- ],
77
- "load_eviction_policies": [
78
- "",
79
- "",
80
- ""
81
- ],
82
- "num_warps": 8,
83
- "num_stages": 1,
84
- "indexing": [
85
- "pointer",
86
- "pointer",
87
- "pointer",
88
- "pointer"
89
- ],
90
- "pid_type": "flat"
91
- },
92
- "default": {
93
- "block_sizes": [
94
- 1,
95
- 512
96
- ],
97
- "loop_orders": [
98
- [
1
+[
2
+ {
3
+ "key": {
4
+ "intermediate": 2048,
5
+ "numtokens": 256
6
+ },
7
+ "config": {
8
+ "block_sizes": [
9
+ 64,
10
+ 32
11
+ ],
12
+ "loop_orders": [
13
+ [
14
+ 0,
15
+ 1
16
+ ]
17
+ ],
18
+ "flatten_loops": [
19
+ true
20
+ ],
21
+ "l2_groupings": [
22
+ 1
23
+ ],
24
+ "range_unroll_factors": [
25
+ 0
26
+ ],
27
+ "range_warp_specializes": [],
28
+ "range_num_stages": [
29
+ 0
30
+ ],
31
+ "range_multi_buffers": [
32
+ null
33
+ ],
34
+ "range_flattens": [
35
+ null
36
+ ],
37
+ "load_eviction_policies": [
38
+ "",
39
+ "",
40
+ ""
41
+ ],
42
+ "num_warps": 8,
43
+ "num_stages": 1,
44
+ "indexing": [
45
+ "pointer",
46
+ "pointer",
47
+ "pointer",
48
+ "pointer"
49
+ ],
50
+ "pid_type": "flat"
51
+ }
52
+ },
53
+ {
54
+ "key": {
55
+ "intermediate": 4096,
56
+ "numtokens": 256
57
+ },
58
+ "config": {
59
+ "block_sizes": [
60
+ 256,
61
+ 32
62
+ ],
63
+ "loop_orders": [
64
+ [
65
+ 0,
66
+ 1
67
+ ]
68
+ ],
69
+ "flatten_loops": [
70
+ true
71
+ ],
72
+ "l2_groupings": [
73
+ 1
74
+ ],
75
+ "range_unroll_factors": [
76
+ 0
77
+ ],
78
+ "range_warp_specializes": [],
79
+ "range_num_stages": [
80
+ 0
81
+ ],
82
+ "range_multi_buffers": [
83
+ null
84
+ ],
85
+ "range_flattens": [
86
+ null
87
+ ],
88
+ "load_eviction_policies": [
89
+ "",
90
+ "",
91
+ ""
92
+ ],
93
+ "num_warps": 8,
94
+ "num_stages": 1,
95
+ "indexing": [
96
+ "pointer",
97
+ "pointer",
98
+ "pointer",
99
+ "pointer"
100
+ ],
101
+ "pid_type": "flat"
102
+ }
103
+ },
104
+ {
105
+ "key": {},
106
+ "config": {
107
+ "block_sizes": [
108
+ 1,
109
+ 512
110
+ ],
111
+ "loop_orders": [
112
+ [
113
+ 1,
114
+ 0
115
+ ]
116
+ ],
117
+ "flatten_loops": [
118
+ false
119
+ ],
120
+ "l2_groupings": [
121
+ 4
122
+ ],
123
+ "range_unroll_factors": [
124
+ 0
125
+ ],
126
+ "range_warp_specializes": [],
127
+ "range_num_stages": [
128
+ 0
129
+ ],
130
+ "range_multi_buffers": [
131
+ null
132
+ ],
133
+ "range_flattens": [
134
+ null
135
+ ],
136
+ "load_eviction_policies": [
137
+ "",
138
+ "first",
139
+ ""
140
+ ],
141
+ "num_warps": 8,
142
+ "num_stages": 2,
143
+ "indexing": [
144
+ "tensor_descriptor",
145
+ "tensor_descriptor",
146
+ "tensor_descriptor",
147
+ "pointer"
148
+ ],
149
+ "pid_type": "flat"
150
+ }
151
+ },
152
+ {
153
+ "key": {
154
+ "intermediate": 8192,
155
+ "numtokens": 256
156
+ },
157
+ "config": {
158
+ "block_sizes": [
159
+ 256,
160
+ 64
161
+ ],
162
+ "loop_orders": [
163
+ [
164
+ 0,
165
+ 1
166
+ ]
167
+ ],
168
+ "flatten_loops": [
169
+ true
170
+ ],
171
+ "l2_groupings": [
172
+ 1
173
+ ],
174
+ "range_unroll_factors": [
175
+ 0
176
+ ],
177
+ "range_warp_specializes": [],
178
+ "range_num_stages": [
179
+ 0
180
+ ],
181
+ "range_multi_buffers": [
182
+ null
183
+ ],
184
+ "range_flattens": [
185
+ null
186
+ ],
187
+ "load_eviction_policies": [
188
+ "",
189
+ "",
190
+ ""
191
+ ],
192
+ "num_warps": 8,
193
+ "num_stages": 1,
194
+ "indexing": [
195
+ "pointer",
196
+ "pointer",
197
+ "pointer",
198
+ "pointer"
199
+ ],
200
+ "pid_type": "flat"
201
+ }
202
+ },
203
+ {
204
+ "key": {
205
+ "intermediate": 14336,
206
+ "numtokens": 256
207
+ },
208
+ "config": {
209
+ "block_sizes": [
210
+ 8,
211
+ 4096
212
+ ],
213
+ "loop_orders": [
214
+ [
215
+ 0,
216
+ 1
217
+ ]
218
+ ],
219
+ "flatten_loops": [
220
+ true
221
+ ],
222
+ "l2_groupings": [
223
+ 1
224
+ ],
225
+ "range_unroll_factors": [
226
+ 0
227
+ ],
228
+ "range_warp_specializes": [],
229
+ "range_num_stages": [
230
+ 0
231
+ ],
232
+ "range_multi_buffers": [
233
+ null
234
+ ],
235
+ "range_flattens": [
236
+ null
237
+ ],
238
+ "load_eviction_policies": [
239
+ "",
240
+ "",
241
+ ""
242
+ ],
243
+ "num_warps": 8,
244
+ "num_stages": 1,
245
+ "indexing": [
246
+ "pointer",
247
+ "pointer",
248
+ "pointer",
249
+ "pointer"
250
+ ],
251
+ "pid_type": "flat"
252
+ }
253
+ },
254
+ {
255
+ "key": {
256
+ "intermediate": 11008,
257
+ "numtokens": 256
258
+ },
259
+ "config": {
260
+ "block_sizes": [
261
+ 64,
262
+ 32
263
+ ],
264
+ "loop_orders": [
265
+ [
266
+ 0,
267
+ 1
268
+ ]
269
+ ],
270
+ "flatten_loops": [
271
+ true
272
+ ],
273
+ "l2_groupings": [
274
+ 1
275
+ ],
276
+ "range_unroll_factors": [
277
+ 0
278
+ ],
279
+ "range_warp_specializes": [],
280
+ "range_num_stages": [
281
+ 0
282
+ ],
283
+ "range_multi_buffers": [
284
+ null
285
+ ],
286
+ "range_flattens": [
287
+ null
288
+ ],
289
+ "load_eviction_policies": [
290
+ "",
291
+ "",
292
+ ""
293
+ ],
294
+ "num_warps": 2,
295
+ "num_stages": 1,
296
+ "indexing": [
297
+ "pointer",
298
+ "pointer",
299
+ "pointer",
300
+ "pointer"
301
+ ],
302
+ "pid_type": "flat"
303
+ }
304
+ },
305
+ {
306
+ "key": {
307
+ "intermediate": 7688,
308
+ "numtokens": 256
309
+ },
310
+ "config": {
311
+ "block_sizes": [
312
+ 32,
313
+ 512
314
+ ],
315
+ "loop_orders": [
316
+ [
317
+ 0,
318
+ 1
319
+ ]
320
+ ],
321
+ "flatten_loops": [
322
+ true
323
+ ],
324
+ "l2_groupings": [
325
+ 1
326
+ ],
327
+ "range_unroll_factors": [
328
+ 0
329
+ ],
330
+ "range_warp_specializes": [],
331
+ "range_num_stages": [
332
+ 0
333
+ ],
334
+ "range_multi_buffers": [
335
+ null
336
+ ],
337
+ "range_flattens": [
338
+ null
339
+ ],
340
+ "load_eviction_policies": [
341
+ "",
342
+ "",
343
+ ""
344
+ ],
345
+ "num_warps": 8,
346
+ "num_stages": 1,
347
+ "indexing": [
348
+ "pointer",
349
+ "pointer",
350
+ "pointer",
351
+ "pointer"
352
+ ],
353
+ "pid_type": "flat"
354
+ }
355
+ },
356
+ {
357
+ "key": {
358
+ "intermediate": 2880,
359
+ "numtokens": 256
360
+ },
361
+ "config": {
362
+ "block_sizes": [
363
+ 32,
364
+ 64
365
+ ],
366
+ "loop_orders": [
367
+ [
368
+ 0,
369
+ 1
370
+ ]
371
+ ],
372
+ "flatten_loops": [
373
+ true
374
+ ],
375
+ "l2_groupings": [
376
+ 2
377
+ ],
378
+ "range_unroll_factors": [
379
+ 0
380
+ ],
381
+ "range_warp_specializes": [],
382
+ "range_num_stages": [
383
+ 0
384
+ ],
385
+ "range_multi_buffers": [
386
+ null
387
+ ],
388
+ "range_flattens": [
389
+ null
390
+ ],
391
+ "load_eviction_policies": [
392
+ "",
393
+ "",
394
+ ""
395
+ ],
396
+ "num_warps": 8,
397
+ "num_stages": 1,
398
+ "indexing": [
399
+ "pointer",
400
+ "pointer",
401
+ "pointer",
402
+ "pointer"
403
+ ],
404
+ "pid_type": "flat"
405
+ }
406
+ },
407
+ {
408
+ "key": {
409
+ "intermediate": 2048,
410
+ "numtokens": 1
411
+ },
412
+ "config": {
413
+ "block_sizes": [
414
+ 1,
415
+ 256
416
+ ],
417
+ "loop_orders": [
418
+ [
419
+ 0,
420
+ 1
421
+ ]
422
+ ],
423
+ "flatten_loops": [
424
+ true
425
+ ],
426
+ "l2_groupings": [
427
+ 1
428
+ ],
429
+ "range_unroll_factors": [
430
+ 0
431
+ ],
432
+ "range_warp_specializes": [],
433
+ "range_num_stages": [
434
+ 0
435
+ ],
436
+ "range_multi_buffers": [
437
+ null
438
+ ],
439
+ "range_flattens": [
440
+ null
441
+ ],
442
+ "load_eviction_policies": [
443
+ "",
444
+ "",
445
+ ""
446
+ ],
447
+ "num_warps": 2,
448
+ "num_stages": 1,
449
+ "indexing": [
450
+ "pointer",
451
+ "pointer",
452
+ "pointer",
453
+ "pointer"
454
+ ],
455
+ "pid_type": "flat"
456
+ }
457
+ },
458
+ {
459
+ "key": {
460
+ "intermediate": 2880,
461
+ "numtokens": 1
462
+ },
463
+ "config": {
464
+ "block_sizes": [
465
+ 1,
466
+ 128
467
+ ],
468
+ "loop_orders": [
469
+ [
470
+ 0,
471
+ 1
472
+ ]
473
+ ],
474
+ "flatten_loops": [
475
+ true
476
+ ],
477
+ "l2_groupings": [
478
+ 1
479
+ ],
480
+ "range_unroll_factors": [
481
+ 0
482
+ ],
483
+ "range_warp_specializes": [],
484
+ "range_num_stages": [
485
+ 0
486
+ ],
487
+ "range_multi_buffers": [
488
+ null
489
+ ],
490
+ "range_flattens": [
491
+ null
492
+ ],
493
+ "load_eviction_policies": [
494
+ "",
495
+ "",
496
+ ""
497
+ ],
498
+ "num_warps": 4,
499
+ "num_stages": 1,
500
+ "indexing": [
501
+ "pointer",
502
+ "pointer",
503
+ "pointer",
504
+ "pointer"
505
+ ],
506
+ "pid_type": "flat"
507
+ }
508
+ },
509
+ {
510
+ "key": {
511
+ "intermediate": 4096,
512
+ "numtokens": 1
513
+ },
514
+ "config": {
515
+ "block_sizes": [
516
+ 1,
517
+ 256
518
+ ],
519
+ "loop_orders": [
520
+ [
521
+ 0,
522
+ 1
523
+ ]
524
+ ],
525
+ "flatten_loops": [
526
+ true
527
+ ],
528
+ "l2_groupings": [
529
+ 1
530
+ ],
531
+ "range_unroll_factors": [
532
+ 0
533
+ ],
534
+ "range_warp_specializes": [],
535
+ "range_num_stages": [
536
+ 0
537
+ ],
538
+ "range_multi_buffers": [
539
+ null
540
+ ],
541
+ "range_flattens": [
542
+ null
543
+ ],
544
+ "load_eviction_policies": [
545
+ "",
546
+ "",
547
+ ""
548
+ ],
549
+ "num_warps": 2,
550
+ "num_stages": 1,
551
+ "indexing": [
552
+ "pointer",
553
+ "pointer",
554
+ "pointer",
555
+ "pointer"
556
+ ],
557
+ "pid_type": "flat"
558
+ }
559
+ },
560
+ {
561
+ "key": {
562
+ "intermediate": 8192,
563
+ "numtokens": 1
564
+ },
565
+ "config": {
566
+ "block_sizes": [
567
+ 1,
568
+ 256
569
+ ],
570
+ "loop_orders": [
571
+ [
572
+ 0,
573
+ 1
574
+ ]
575
+ ],
576
+ "flatten_loops": [
577
+ true
578
+ ],
579
+ "l2_groupings": [
580
+ 1
581
+ ],
582
+ "range_unroll_factors": [
583
+ 0
584
+ ],
585
+ "range_warp_specializes": [],
586
+ "range_num_stages": [
587
+ 0
588
+ ],
589
+ "range_multi_buffers": [
590
+ null
591
+ ],
592
+ "range_flattens": [
593
+ null
594
+ ],
595
+ "load_eviction_policies": [
596
+ "",
597
+ "",
598
+ ""
599
+ ],
600
+ "num_warps": 2,
601
+ "num_stages": 1,
602
+ "indexing": [
603
+ "pointer",
604
+ "pointer",
605
+ "pointer",
606
+ "pointer"
607
+ ],
608
+ "pid_type": "flat"
609
+ }
610
+ },
611
+ {
612
+ "key": {
613
+ "intermediate": 11008,
614
+ "numtokens": 1
615
+ },
616
+ "config": {
617
+ "block_sizes": [
618
+ 1,
619
+ 256
620
+ ],
621
+ "loop_orders": [
622
+ [
623
+ 0,
624
+ 1
625
+ ]
626
+ ],
627
+ "flatten_loops": [
628
+ true
629
+ ],
630
+ "l2_groupings": [
631
+ 1
632
+ ],
633
+ "range_unroll_factors": [
634
+ 0
635
+ ],
636
+ "range_warp_specializes": [],
637
+ "range_num_stages": [
638
+ 0
639
+ ],
640
+ "range_multi_buffers": [
641
+ null
642
+ ],
643
+ "range_flattens": [
644
+ null
645
+ ],
646
+ "load_eviction_policies": [
647
+ "",
648
+ "",
649
+ ""
650
+ ],
651
+ "num_warps": 2,
652
+ "num_stages": 1,
653
+ "indexing": [
654
+ "pointer",
655
+ "pointer",
656
+ "pointer",
657
+ "pointer"
658
+ ],
659
+ "pid_type": "flat"
660
+ }
661
+ },
662
+ {
663
+ "key": {
664
+ "intermediate": 14336,
665
+ "numtokens": 1
666
+ },
667
+ "config": {
668
+ "block_sizes": [
669
+ 1,
670
+ 256
671
+ ],
672
+ "loop_orders": [
673
+ [
674
+ 0,
675
+ 1
676
+ ]
677
+ ],
678
+ "flatten_loops": [
679
+ true
680
+ ],
681
+ "l2_groupings": [
682
+ 1
683
+ ],
684
+ "range_unroll_factors": [
685
+ 0
686
+ ],
687
+ "range_warp_specializes": [],
688
+ "range_num_stages": [
689
+ 0
690
+ ],
691
+ "range_multi_buffers": [
692
+ null
693
+ ],
694
+ "range_flattens": [
695
+ null
696
+ ],
697
+ "load_eviction_policies": [
698
+ "",
699
+ "",
700
+ ""
701
+ ],
702
+ "num_warps": 2,
703
+ "num_stages": 1,
704
+ "indexing": [
705
+ "pointer",
706
+ "pointer",
707
+ "pointer",
708
+ "pointer"
709
+ ],
710
+ "pid_type": "flat"
711
+ }
712
+ },
713
+ {
714
+ "key": {
715
+ "intermediate": 2048,
716
+ "numtokens": 2
717
+ },
718
+ "config": {
719
+ "block_sizes": [
720
+ 2,
721
+ 128
722
+ ],
723
+ "loop_orders": [
724
+ [
725
+ 0,
726
+ 1
727
+ ]
728
+ ],
729
+ "flatten_loops": [
730
+ true
731
+ ],
732
+ "l2_groupings": [
733
+ 1
734
+ ],
735
+ "range_unroll_factors": [
736
+ 0
737
+ ],
738
+ "range_warp_specializes": [],
739
+ "range_num_stages": [
740
+ 0
741
+ ],
742
+ "range_multi_buffers": [
743
+ null
744
+ ],
745
+ "range_flattens": [
746
+ null
747
+ ],
748
+ "load_eviction_policies": [
749
+ "",
750
+ "",
751
+ ""
752
+ ],
753
+ "num_warps": 2,
754
+ "num_stages": 1,
755
+ "indexing": [
756
+ "pointer",
757
+ "pointer",
758
+ "pointer",
759
+ "pointer"
760
+ ],
761
+ "pid_type": "flat"
762
+ }
763
+ },
764
+ {
765
+ "key": {
766
+ "intermediate": 2880,
767
+ "numtokens": 2
768
+ },
769
+ "config": {
770
+ "block_sizes": [
771
+ 2,
772
+ 256
773
+ ],
774
+ "loop_orders": [
775
+ [
776
+ 0,
777
+ 1
778
+ ]
779
+ ],
780
+ "flatten_loops": [
781
+ true
782
+ ],
783
+ "l2_groupings": [
784
+ 1
785
+ ],
786
+ "range_unroll_factors": [
787
+ 0
788
+ ],
789
+ "range_warp_specializes": [],
790
+ "range_num_stages": [
791
+ 0
792
+ ],
793
+ "range_multi_buffers": [
794
+ null
795
+ ],
796
+ "range_flattens": [
797
+ null
798
+ ],
799
+ "load_eviction_policies": [
800
+ "",
801
+ "",
802
+ ""
803
+ ],
804
+ "num_warps": 4,
805
+ "num_stages": 1,
806
+ "indexing": [
807
+ "pointer",
808
+ "pointer",
809
+ "pointer",
810
+ "pointer"
811
+ ],
812
+ "pid_type": "flat"
813
+ }
814
+ },
815
+ {
816
+ "key": {
817
+ "intermediate": 4096,
818
+ "numtokens": 2
819
+ },
820
+ "config": {
821
+ "block_sizes": [
822
+ 2,
823
+ 128
824
+ ],
825
+ "loop_orders": [
826
+ [
827
+ 0,
828
+ 1
829
+ ]
830
+ ],
831
+ "flatten_loops": [
832
+ true
833
+ ],
834
+ "l2_groupings": [
835
+ 1
836
+ ],
837
+ "range_unroll_factors": [
838
+ 0
839
+ ],
840
+ "range_warp_specializes": [],
841
+ "range_num_stages": [
842
+ 0
843
+ ],
844
+ "range_multi_buffers": [
845
+ null
846
+ ],
847
+ "range_flattens": [
848
+ null
849
+ ],
850
+ "load_eviction_policies": [
851
+ "",
852
+ "",
853
+ ""
854
+ ],
855
+ "num_warps": 2,
856
+ "num_stages": 1,
857
+ "indexing": [
858
+ "pointer",
859
+ "pointer",
860
+ "pointer",
861
+ "pointer"
862
+ ],
863
+ "pid_type": "flat"
864
+ }
865
+ },
866
+ {
867
+ "key": {
868
+ "intermediate": 8192,
869
+ "numtokens": 2
870
+ },
871
+ "config": {
872
+ "block_sizes": [
873
+ 2,
874
+ 128
875
+ ],
876
+ "loop_orders": [
877
+ [
878
+ 0,
879
+ 1
880
+ ]
881
+ ],
882
+ "flatten_loops": [
883
+ true
884
+ ],
885
+ "l2_groupings": [
886
+ 1
887
+ ],
888
+ "range_unroll_factors": [
889
+ 0
890
+ ],
891
+ "range_warp_specializes": [],
892
+ "range_num_stages": [
893
+ 0
894
+ ],
895
+ "range_multi_buffers": [
896
+ null
897
+ ],
898
+ "range_flattens": [
899
+ null
900
+ ],
901
+ "load_eviction_policies": [
902
+ "",
903
+ "",
904
+ ""
905
+ ],
906
+ "num_warps": 2,
907
+ "num_stages": 1,
908
+ "indexing": [
909
+ "pointer",
910
+ "pointer",
911
+ "pointer",
912
+ "pointer"
913
+ ],
914
+ "pid_type": "flat"
915
+ }
916
+ },
917
+ {
918
+ "key": {
919
+ "intermediate": 11008,
920
+ "numtokens": 2
921
+ },
922
+ "config": {
923
+ "block_sizes": [
924
+ 1,
925
+ 16384
926
+ ],
927
+ "loop_orders": [
928
+ [
929
+ 1,
930
+ 0
931
+ ]
932
+ ],
933
+ "flatten_loops": [
934
+ true
935
+ ],
936
+ "l2_groupings": [
937
+ 16
938
+ ],
939
+ "range_unroll_factors": [
940
+ 0
941
+ ],
942
+ "range_warp_specializes": [],
943
+ "range_num_stages": [
944
+ 0
945
+ ],
946
+ "range_multi_buffers": [
947
+ null
948
+ ],
949
+ "range_flattens": [
950
+ null
951
+ ],
952
+ "load_eviction_policies": [
953
+ "last",
954
+ "first",
955
+ "last"
956
+ ],
957
+ "num_warps": 32,
958
+ "num_stages": 3,
959
+ "indexing": [
960
+ "tensor_descriptor",
961
+ "pointer",
962
+ "pointer",
963
+ "tensor_descriptor"
964
+ ],
965
+ "pid_type": "xyz"
966
+ }
967
+ },
968
+ {
969
+ "key": {
970
+ "intermediate": 14336,
971
+ "numtokens": 2
972
+ },
973
+ "config": {
974
+ "block_sizes": [
975
+ 2,
976
+ 128
977
+ ],
978
+ "loop_orders": [
979
+ [
980
+ 0,
981
+ 1
982
+ ]
983
+ ],
984
+ "flatten_loops": [
985
+ true
986
+ ],
987
+ "l2_groupings": [
988
+ 1
989
+ ],
990
+ "range_unroll_factors": [
991
+ 0
992
+ ],
993
+ "range_warp_specializes": [],
994
+ "range_num_stages": [
995
+ 0
996
+ ],
997
+ "range_multi_buffers": [
998
+ null
999
+ ],
1000
+ "range_flattens": [
1001
+ null
1002
+ ],
1003
+ "load_eviction_policies": [
1004
+ "",
1005
+ "",
1006
+ ""
1007
+ ],
1008
+ "num_warps": 2,
1009
+ "num_stages": 1,
1010
+ "indexing": [
1011
+ "pointer",
1012
+ "pointer",
1013
+ "pointer",
1014
+ "pointer"
1015
+ ],
1016
+ "pid_type": "flat"
1017
+ }
1018
+ },
1019
+ {
1020
+ "key": {
1021
+ "intermediate": 2048,
1022
+ "numtokens": 4
1023
+ },
1024
+ "config": {
1025
+ "block_sizes": [
1026
+ 4,
1027
+ 64
1028
+ ],
1029
+ "loop_orders": [
1030
+ [
1031
+ 0,
1032
+ 1
1033
+ ]
1034
+ ],
1035
+ "flatten_loops": [
1036
+ true
1037
+ ],
1038
+ "l2_groupings": [
1039
+ 1
1040
+ ],
1041
+ "range_unroll_factors": [
1042
+ 0
1043
+ ],
1044
+ "range_warp_specializes": [],
1045
+ "range_num_stages": [
1046
+ 0
1047
+ ],
1048
+ "range_multi_buffers": [
1049
+ null
1050
+ ],
1051
+ "range_flattens": [
1052
+ null
1053
+ ],
1054
+ "load_eviction_policies": [
1055
+ "",
1056
+ "",
1057
+ ""
1058
+ ],
1059
+ "num_warps": 2,
1060
+ "num_stages": 1,
1061
+ "indexing": [
1062
+ "pointer",
1063
+ "pointer",
1064
+ "pointer",
1065
+ "pointer"
1066
+ ],
1067
+ "pid_type": "flat"
1068
+ }
1069
+ },
1070
+ {
1071
+ "key": {
1072
+ "intermediate": 2880,
1073
+ "numtokens": 4
1074
+ },
1075
+ "config": {
1076
+ "block_sizes": [
1077
+ 4,
1078
+ 64
1079
+ ],
1080
+ "loop_orders": [
1081
+ [
1082
+ 0,
1083
+ 1
1084
+ ]
1085
+ ],
1086
+ "flatten_loops": [
1087
+ true
1088
+ ],
1089
+ "l2_groupings": [
1090
+ 64
1091
+ ],
1092
+ "range_unroll_factors": [
1093
+ 0
1094
+ ],
1095
+ "range_warp_specializes": [],
1096
+ "range_num_stages": [
1097
+ 0
1098
+ ],
1099
+ "range_multi_buffers": [
1100
+ null
1101
+ ],
1102
+ "range_flattens": [
1103
+ null
1104
+ ],
1105
+ "load_eviction_policies": [
1106
+ "",
1107
+ "last",
1108
+ "first"
1109
+ ],
1110
+ "num_warps": 8,
1111
+ "num_stages": 7,
1112
+ "indexing": [
1113
+ "pointer",
1114
+ "tensor_descriptor",
1115
+ "tensor_descriptor",
1116
+ "pointer"
1117
+ ],
1118
+ "pid_type": "xyz"
1119
+ }
1120
+ },
1121
+ {
1122
+ "key": {
1123
+ "intermediate": 4096,
1124
+ "numtokens": 4
1125
+ },
1126
+ "config": {
1127
+ "block_sizes": [
1128
+ 4,
1129
+ 64
1130
+ ],
1131
+ "loop_orders": [
1132
+ [
1133
+ 0,
1134
+ 1
1135
+ ]
1136
+ ],
1137
+ "flatten_loops": [
1138
+ true
1139
+ ],
1140
+ "l2_groupings": [
1141
+ 1
1142
+ ],
1143
+ "range_unroll_factors": [
1144
+ 0
1145
+ ],
1146
+ "range_warp_specializes": [],
1147
+ "range_num_stages": [
1148
+ 0
1149
+ ],
1150
+ "range_multi_buffers": [
1151
+ null
1152
+ ],
1153
+ "range_flattens": [
1154
+ null
1155
+ ],
1156
+ "load_eviction_policies": [
1157
+ "",
1158
+ "",
1159
+ ""
1160
+ ],
1161
+ "num_warps": 2,
1162
+ "num_stages": 1,
1163
+ "indexing": [
1164
+ "pointer",
1165
+ "pointer",
1166
+ "pointer",
1167
+ "pointer"
1168
+ ],
1169
+ "pid_type": "flat"
1170
+ }
1171
+ },
1172
+ {
1173
+ "key": {
1174
+ "intermediate": 8192,
1175
+ "numtokens": 4
1176
+ },
1177
+ "config": {
1178
+ "block_sizes": [
1179
+ 1,
1180
+ 2048
1181
+ ],
1182
+ "loop_orders": [
1183
+ [
1184
+ 0,
1185
+ 1
1186
+ ]
1187
+ ],
1188
+ "flatten_loops": [
1189
+ false
1190
+ ],
1191
+ "l2_groupings": [
1192
+ 1
1193
+ ],
1194
+ "range_unroll_factors": [
1195
+ 0
1196
+ ],
1197
+ "range_warp_specializes": [],
1198
+ "range_num_stages": [
1199
+ 0
1200
+ ],
1201
+ "range_multi_buffers": [
1202
+ null
1203
+ ],
1204
+ "range_flattens": [
1205
+ null
1206
+ ],
1207
+ "load_eviction_policies": [
1208
+ "",
1209
+ "",
1210
+ ""
1211
+ ],
1212
+ "num_warps": 8,
1213
+ "num_stages": 8,
1214
+ "indexing": [
1215
+ "pointer",
1216
+ "tensor_descriptor",
1217
+ "pointer",
1218
+ "pointer"
1219
+ ],
1220
+ "pid_type": "flat"
1221
+ }
1222
+ },
1223
+ {
1224
+ "key": {
1225
+ "intermediate": 11008,
1226
+ "numtokens": 4
1227
+ },
1228
+ "config": {
1229
+ "block_sizes": [
1230
+ 4,
1231
+ 2048
1232
+ ],
1233
+ "loop_orders": [
1234
+ [
1235
+ 1,
1236
+ 0
1237
+ ]
1238
+ ],
1239
+ "flatten_loops": [
1240
+ true
1241
+ ],
1242
+ "l2_groupings": [
1243
+ 4
1244
+ ],
1245
+ "range_unroll_factors": [
1246
+ 0
1247
+ ],
1248
+ "range_warp_specializes": [],
1249
+ "range_num_stages": [
1250
+ 0
1251
+ ],
1252
+ "range_multi_buffers": [
1253
+ null
1254
+ ],
1255
+ "range_flattens": [
1256
+ null
1257
+ ],
1258
+ "load_eviction_policies": [
1259
+ "first",
1260
+ "last",
1261
+ "last"
1262
+ ],
1263
+ "num_warps": 8,
1264
+ "num_stages": 6,
1265
+ "indexing": [
1266
+ "pointer",
1267
+ "tensor_descriptor",
1268
+ "tensor_descriptor",
1269
+ "tensor_descriptor"
1270
+ ],
1271
+ "pid_type": "xyz"
1272
+ }
1273
+ },
1274
+ {
1275
+ "key": {
1276
+ "intermediate": 14336,
1277
+ "numtokens": 4
1278
+ },
1279
+ "config": {
1280
+ "block_sizes": [
1281
+ 4,
1282
+ 256
1283
+ ],
1284
+ "loop_orders": [
1285
+ [
1286
+ 0,
1287
+ 1
1288
+ ]
1289
+ ],
1290
+ "flatten_loops": [
1291
+ true
1292
+ ],
1293
+ "l2_groupings": [
1294
+ 64
1295
+ ],
1296
+ "range_unroll_factors": [
1297
+ 0
1298
+ ],
1299
+ "range_warp_specializes": [],
1300
+ "range_num_stages": [
1301
+ 0
1302
+ ],
1303
+ "range_multi_buffers": [
1304
+ null
1305
+ ],
1306
+ "range_flattens": [
1307
+ null
1308
+ ],
1309
+ "load_eviction_policies": [
1310
+ "",
1311
+ "",
1312
+ ""
1313
+ ],
1314
+ "num_warps": 2,
1315
+ "num_stages": 2,
1316
+ "indexing": [
1317
+ "pointer",
1318
+ "pointer",
1319
+ "pointer",
1320
+ "pointer"
1321
+ ],
1322
+ "pid_type": "xyz"
1323
+ }
1324
+ },
1325
+ {
1326
+ "key": {
1327
+ "intermediate": 2048,
1328
+ "numtokens": 8
1329
+ },
1330
+ "config": {
1331
+ "block_sizes": [
1332
+ 8,
1333
+ 32
1334
+ ],
1335
+ "loop_orders": [
1336
+ [
1337
+ 0,
1338
+ 1
1339
+ ]
1340
+ ],
1341
+ "flatten_loops": [
1342
+ true
1343
+ ],
1344
+ "l2_groupings": [
1345
+ 1
1346
+ ],
1347
+ "range_unroll_factors": [
1348
+ 0
1349
+ ],
1350
+ "range_warp_specializes": [],
1351
+ "range_num_stages": [
1352
+ 0
1353
+ ],
1354
+ "range_multi_buffers": [
1355
+ null
1356
+ ],
1357
+ "range_flattens": [
1358
+ null
1359
+ ],
1360
+ "load_eviction_policies": [
1361
+ "",
1362
+ "",
1363
+ ""
1364
+ ],
1365
+ "num_warps": 2,
1366
+ "num_stages": 1,
1367
+ "indexing": [
1368
+ "pointer",
1369
+ "pointer",
1370
+ "pointer",
1371
+ "pointer"
1372
+ ],
1373
+ "pid_type": "flat"
1374
+ }
1375
+ },
1376
+ {
1377
+ "key": {
1378
+ "intermediate": 2880,
1379
+ "numtokens": 8
1380
+ },
1381
+ "config": {
1382
+ "block_sizes": [
1383
+ 4,
1384
+ 2048
1385
+ ],
1386
+ "loop_orders": [
1387
+ [
1388
+ 0,
1389
+ 1
1390
+ ]
1391
+ ],
1392
+ "flatten_loops": [
1393
+ true
1394
+ ],
1395
+ "l2_groupings": [
1396
+ 4
1397
+ ],
1398
+ "range_unroll_factors": [
1399
+ 0
1400
+ ],
1401
+ "range_warp_specializes": [],
1402
+ "range_num_stages": [
1403
+ 0
1404
+ ],
1405
+ "range_multi_buffers": [
1406
+ null
1407
+ ],
1408
+ "range_flattens": [
1409
+ null
1410
+ ],
1411
+ "load_eviction_policies": [
1412
+ "last",
1413
+ "last",
1414
+ ""
1415
+ ],
1416
+ "num_warps": 16,
1417
+ "num_stages": 5,
1418
+ "indexing": [
1419
+ "pointer",
1420
+ "tensor_descriptor",
1421
+ "tensor_descriptor",
1422
+ "pointer"
1423
+ ],
1424
+ "pid_type": "xyz"
1425
+ }
1426
+ },
1427
+ {
1428
+ "key": {
1429
+ "intermediate": 4096,
1430
+ "numtokens": 8
1431
+ },
1432
+ "config": {
1433
+ "block_sizes": [
1434
+ 8,
1435
+ 32
1436
+ ],
1437
+ "loop_orders": [
1438
+ [
1439
+ 0,
1440
+ 1
1441
+ ]
1442
+ ],
1443
+ "flatten_loops": [
1444
+ true
1445
+ ],
1446
+ "l2_groupings": [
1447
+ 1
1448
+ ],
1449
+ "range_unroll_factors": [
1450
+ 0
1451
+ ],
1452
+ "range_warp_specializes": [],
1453
+ "range_num_stages": [
1454
+ 0
1455
+ ],
1456
+ "range_multi_buffers": [
1457
+ null
1458
+ ],
1459
+ "range_flattens": [
1460
+ null
1461
+ ],
1462
+ "load_eviction_policies": [
1463
+ "",
1464
+ "",
1465
+ ""
1466
+ ],
1467
+ "num_warps": 2,
1468
+ "num_stages": 1,
1469
+ "indexing": [
1470
+ "pointer",
1471
+ "pointer",
1472
+ "pointer",
1473
+ "pointer"
1474
+ ],
1475
+ "pid_type": "flat"
1476
+ }
1477
+ },
1478
+ {
1479
+ "key": {
1480
+ "intermediate": 8192,
1481
+ "numtokens": 8
1482
+ },
1483
+ "config": {
1484
+ "block_sizes": [
1485
+ 2,
1486
+ 1024
1487
+ ],
1488
+ "loop_orders": [
1489
+ [
1490
+ 0,
1491
+ 1
1492
+ ]
1493
+ ],
1494
+ "flatten_loops": [
1495
+ true
1496
+ ],
1497
+ "l2_groupings": [
1498
+ 16
1499
+ ],
1500
+ "range_unroll_factors": [
1501
+ 0
1502
+ ],
1503
+ "range_warp_specializes": [],
1504
+ "range_num_stages": [
1505
+ 0
1506
+ ],
1507
+ "range_multi_buffers": [
1508
+ null
1509
+ ],
1510
+ "range_flattens": [
1511
+ null
1512
+ ],
1513
+ "load_eviction_policies": [
1514
+ "first",
1515
+ "last",
1516
+ ""
1517
+ ],
1518
+ "num_warps": 1,
1519
+ "num_stages": 8,
1520
+ "indexing": [
1521
+ "tensor_descriptor",
1522
+ "pointer",
1523
+ "tensor_descriptor",
1524
+ "pointer"
1525
+ ],
1526
+ "pid_type": "flat"
1527
+ }
1528
+ },
1529
+ {
1530
+ "key": {
1531
+ "intermediate": 11008,
1532
+ "numtokens": 8
1533
+ },
1534
+ "config": {
1535
+ "block_sizes": [
1536
+ 1,
1537
+ 1024
1538
+ ],
1539
+ "loop_orders": [
1540
+ [
1541
+ 1,
1542
+ 0
1543
+ ]
1544
+ ],
1545
+ "flatten_loops": [
1546
+ true
1547
+ ],
1548
+ "l2_groupings": [
1549
+ 4
1550
+ ],
1551
+ "range_unroll_factors": [
1552
+ 0
1553
+ ],
1554
+ "range_warp_specializes": [],
1555
+ "range_num_stages": [
1556
+ 0
1557
+ ],
1558
+ "range_multi_buffers": [
1559
+ null
1560
+ ],
1561
+ "range_flattens": [
1562
+ null
1563
+ ],
1564
+ "load_eviction_policies": [
1565
+ "last",
1566
+ "",
1567
+ "first"
1568
+ ],
1569
+ "num_warps": 2,
1570
+ "num_stages": 5,
1571
+ "indexing": [
1572
+ "tensor_descriptor",
1573
+ "tensor_descriptor",
1574
+ "tensor_descriptor",
1575
+ "tensor_descriptor"
1576
+ ],
1577
+ "pid_type": "flat"
1578
+ }
1579
+ },
1580
+ {
1581
+ "key": {
1582
+ "intermediate": 14336,
1583
+ "numtokens": 8
1584
+ },
1585
+ "config": {
1586
+ "block_sizes": [
1587
+ 8,
1588
+ 128
1589
+ ],
1590
+ "loop_orders": [
1591
+ [
1592
+ 0,
1593
+ 1
1594
+ ]
1595
+ ],
1596
+ "flatten_loops": [
1597
+ true
1598
+ ],
1599
+ "l2_groupings": [
1600
+ 1
1601
+ ],
1602
+ "range_unroll_factors": [
1603
+ 0
1604
+ ],
1605
+ "range_warp_specializes": [],
1606
+ "range_num_stages": [
1607
+ 0
1608
+ ],
1609
+ "range_multi_buffers": [
1610
+ null
1611
+ ],
1612
+ "range_flattens": [
1613
+ null
1614
+ ],
1615
+ "load_eviction_policies": [
1616
+ "",
1617
+ "",
1618
+ ""
1619
+ ],
1620
+ "num_warps": 4,
1621
+ "num_stages": 1,
1622
+ "indexing": [
1623
+ "pointer",
1624
+ "pointer",
1625
+ "pointer",
1626
+ "pointer"
1627
+ ],
1628
+ "pid_type": "flat"
1629
+ }
1630
+ },
1631
+ {
1632
+ "key": {
1633
+ "intermediate": 2048,
1634
+ "numtokens": 16
1635
+ },
1636
+ "config": {
1637
+ "block_sizes": [
1638
+ 8,
1639
+ 512
1640
+ ],
1641
+ "loop_orders": [
1642
+ [
1643
+ 0,
1644
+ 1
1645
+ ]
1646
+ ],
1647
+ "flatten_loops": [
1648
+ true
1649
+ ],
1650
+ "l2_groupings": [
1651
+ 64
1652
+ ],
1653
+ "range_unroll_factors": [
1654
+ 0
1655
+ ],
1656
+ "range_warp_specializes": [],
1657
+ "range_num_stages": [
1658
+ 0
1659
+ ],
1660
+ "range_multi_buffers": [
1661
+ null
1662
+ ],
1663
+ "range_flattens": [
1664
+ null
1665
+ ],
1666
+ "load_eviction_policies": [
1667
+ "last",
1668
+ "last",
1669
+ "first"
1670
+ ],
1671
+ "num_warps": 16,
1672
+ "num_stages": 2,
1673
+ "indexing": [
1674
+ "pointer",
1675
+ "pointer",
1676
+ "tensor_descriptor",
1677
+ "pointer"
1678
+ ],
1679
+ "pid_type": "xyz"
1680
+ }
1681
+ },
1682
+ {
1683
+ "key": {
1684
+ "intermediate": 2880,
1685
+ "numtokens": 16
1686
+ },
1687
+ "config": {
1688
+ "block_sizes": [
1689
+ 2,
1690
+ 256
1691
+ ],
1692
+ "loop_orders": [
1693
+ [
1694
+ 0,
1695
+ 1
1696
+ ]
1697
+ ],
1698
+ "flatten_loops": [
1699
+ true
1700
+ ],
1701
+ "l2_groupings": [
1702
+ 1
1703
+ ],
1704
+ "range_unroll_factors": [
1705
+ 0
1706
+ ],
1707
+ "range_warp_specializes": [],
1708
+ "range_num_stages": [
1709
+ 0
1710
+ ],
1711
+ "range_multi_buffers": [
1712
+ null
1713
+ ],
1714
+ "range_flattens": [
1715
+ null
1716
+ ],
1717
+ "load_eviction_policies": [
1718
+ "",
1719
+ "",
1720
+ ""
1721
+ ],
1722
+ "num_warps": 4,
1723
+ "num_stages": 1,
1724
+ "indexing": [
1725
+ "pointer",
1726
+ "pointer",
1727
+ "pointer",
1728
+ "pointer"
1729
+ ],
1730
+ "pid_type": "flat"
1731
+ }
1732
+ },
1733
+ {
1734
+ "key": {
1735
+ "intermediate": 4096,
1736
+ "numtokens": 16
1737
+ },
1738
+ "config": {
1739
+ "block_sizes": [
1740
+ 16,
1741
+ 256
1742
+ ],
1743
+ "loop_orders": [
1744
+ [
1745
+ 0,
1746
+ 1
1747
+ ]
1748
+ ],
1749
+ "flatten_loops": [
1750
+ true
1751
+ ],
1752
+ "l2_groupings": [
1753
+ 16
1754
+ ],
1755
+ "range_unroll_factors": [
1756
+ 0
1757
+ ],
1758
+ "range_warp_specializes": [],
1759
+ "range_num_stages": [
1760
+ 0
1761
+ ],
1762
+ "range_multi_buffers": [
1763
+ null
1764
+ ],
1765
+ "range_flattens": [
1766
+ null
1767
+ ],
1768
+ "load_eviction_policies": [
1769
+ "last",
1770
+ "",
1771
+ "last"
1772
+ ],
1773
+ "num_warps": 32,
1774
+ "num_stages": 1,
1775
+ "indexing": [
1776
+ "pointer",
1777
+ "pointer",
1778
+ "pointer",
1779
+ "pointer"
1780
+ ],
1781
+ "pid_type": "flat"
1782
+ }
1783
+ },
1784
+ {
1785
+ "key": {
1786
+ "intermediate": 8192,
1787
+ "numtokens": 16
1788
+ },
1789
+ "config": {
1790
+ "block_sizes": [
1791
+ 16,
1792
+ 64
1793
+ ],
1794
+ "loop_orders": [
1795
+ [
1796
+ 0,
1797
+ 1
1798
+ ]
1799
+ ],
1800
+ "flatten_loops": [
1801
+ true
1802
+ ],
1803
+ "l2_groupings": [
1804
+ 1
1805
+ ],
1806
+ "range_unroll_factors": [
1807
+ 0
1808
+ ],
1809
+ "range_warp_specializes": [],
1810
+ "range_num_stages": [
1811
+ 0
1812
+ ],
1813
+ "range_multi_buffers": [
1814
+ null
1815
+ ],
1816
+ "range_flattens": [
1817
+ null
1818
+ ],
1819
+ "load_eviction_policies": [
1820
+ "",
1821
+ "",
1822
+ ""
1823
+ ],
1824
+ "num_warps": 4,
1825
+ "num_stages": 1,
1826
+ "indexing": [
1827
+ "pointer",
1828
+ "pointer",
1829
+ "pointer",
1830
+ "pointer"
1831
+ ],
1832
+ "pid_type": "flat"
1833
+ }
1834
+ },
1835
+ {
1836
+ "key": {
1837
+ "intermediate": 11008,
1838
+ "numtokens": 16
1839
+ },
1840
+ "config": {
1841
+ "block_sizes": [
1842
+ 1,
1843
+ 2048
1844
+ ],
1845
+ "loop_orders": [
1846
+ [
1847
+ 0,
1848
+ 1
1849
+ ]
1850
+ ],
1851
+ "flatten_loops": [
1852
+ true
1853
+ ],
1854
+ "l2_groupings": [
1855
+ 1
1856
+ ],
1857
+ "range_unroll_factors": [
1858
+ 0
1859
+ ],
1860
+ "range_warp_specializes": [],
1861
+ "range_num_stages": [
1862
+ 0
1863
+ ],
1864
+ "range_multi_buffers": [
1865
+ null
1866
+ ],
1867
+ "range_flattens": [
1868
+ null
1869
+ ],
1870
+ "load_eviction_policies": [
1871
+ "",
1872
+ "",
1873
+ ""
1874
+ ],
1875
+ "num_warps": 8,
1876
+ "num_stages": 1,
1877
+ "indexing": [
1878
+ "pointer",
1879
+ "pointer",
1880
+ "pointer",
1881
+ "pointer"
1882
+ ],
1883
+ "pid_type": "flat"
1884
+ }
1885
+ },
1886
+ {
1887
+ "key": {
1888
+ "intermediate": 14336,
1889
+ "numtokens": 16
1890
+ },
1891
+ "config": {
1892
+ "block_sizes": [
1893
+ 2,
1894
+ 256
1895
+ ],
1896
+ "loop_orders": [
1897
+ [
1898
+ 1,
1899
+ 0
1900
+ ]
1901
+ ],
1902
+ "flatten_loops": [
1903
+ true
1904
+ ],
1905
+ "l2_groupings": [
1906
+ 64
1907
+ ],
1908
+ "range_unroll_factors": [
1909
+ 0
1910
+ ],
1911
+ "range_warp_specializes": [],
1912
+ "range_num_stages": [
1913
+ 0
1914
+ ],
1915
+ "range_multi_buffers": [
1916
+ null
1917
+ ],
1918
+ "range_flattens": [
1919
+ null
1920
+ ],
1921
+ "load_eviction_policies": [
1922
+ "last",
1923
+ "last",
1924
+ "last"
1925
+ ],
1926
+ "num_warps": 16,
1927
+ "num_stages": 7,
1928
+ "indexing": [
1929
+ "tensor_descriptor",
1930
+ "pointer",
1931
+ "tensor_descriptor",
1932
+ "tensor_descriptor"
1933
+ ],
1934
+ "pid_type": "flat"
1935
+ }
1936
+ },
1937
+ {
1938
+ "key": {
1939
+ "intermediate": 2048,
1940
+ "numtokens": 24
1941
+ },
1942
+ "config": {
1943
+ "block_sizes": [
1944
+ 1,
1945
+ 1024
1946
+ ],
1947
+ "loop_orders": [
1948
+ [
1949
+ 0,
1950
+ 1
1951
+ ]
1952
+ ],
1953
+ "flatten_loops": [
1954
+ true
1955
+ ],
1956
+ "l2_groupings": [
1957
+ 64
1958
+ ],
1959
+ "range_unroll_factors": [
1960
+ 0
1961
+ ],
1962
+ "range_warp_specializes": [],
1963
+ "range_num_stages": [
1964
+ 0
1965
+ ],
1966
+ "range_multi_buffers": [
1967
+ null
1968
+ ],
1969
+ "range_flattens": [
1970
+ null
1971
+ ],
1972
+ "load_eviction_policies": [
1973
+ "",
1974
+ "",
1975
+ "first"
1976
+ ],
1977
+ "num_warps": 4,
1978
+ "num_stages": 8,
1979
+ "indexing": [
1980
+ "tensor_descriptor",
1981
+ "pointer",
1982
+ "pointer",
1983
+ "tensor_descriptor"
1984
+ ],
1985
+ "pid_type": "flat"
1986
+ }
1987
+ },
1988
+ {
1989
+ "key": {
1990
+ "intermediate": 2880,
1991
+ "numtokens": 24
1992
+ },
1993
+ "config": {
1994
+ "block_sizes": [
1995
+ 4,
1996
+ 1024
1997
+ ],
1998
+ "loop_orders": [
1999
+ [
2000
+ 0,
2001
+ 1
2002
+ ]
2003
+ ],
2004
+ "flatten_loops": [
2005
+ true
2006
+ ],
2007
+ "l2_groupings": [
2008
+ 16
2009
+ ],
2010
+ "range_unroll_factors": [
2011
+ 0
2012
+ ],
2013
+ "range_warp_specializes": [],
2014
+ "range_num_stages": [
2015
+ 0
2016
+ ],
2017
+ "range_multi_buffers": [
2018
+ null
2019
+ ],
2020
+ "range_flattens": [
2021
+ null
2022
+ ],
2023
+ "load_eviction_policies": [
2024
+ "first",
2025
+ "",
2026
+ "first"
2027
+ ],
2028
+ "num_warps": 16,
2029
+ "num_stages": 3,
2030
+ "indexing": [
2031
+ "tensor_descriptor",
2032
+ "pointer",
2033
+ "tensor_descriptor",
2034
+ "pointer"
2035
+ ],
2036
+ "pid_type": "flat"
2037
+ }
2038
+ },
2039
+ {
2040
+ "key": {
2041
+ "intermediate": 4096,
2042
+ "numtokens": 24
2043
+ },
2044
+ "config": {
2045
+ "block_sizes": [
2046
+ 16,
2047
+ 64
2048
+ ],
2049
+ "loop_orders": [
2050
+ [
2051
+ 0,
2052
+ 1
2053
+ ]
2054
+ ],
2055
+ "flatten_loops": [
2056
+ true
2057
+ ],
2058
+ "l2_groupings": [
2059
+ 1
2060
+ ],
2061
+ "range_unroll_factors": [
2062
+ 0
2063
+ ],
2064
+ "range_warp_specializes": [],
2065
+ "range_num_stages": [
2066
+ 0
2067
+ ],
2068
+ "range_multi_buffers": [
2069
+ null
2070
+ ],
2071
+ "range_flattens": [
2072
+ null
2073
+ ],
2074
+ "load_eviction_policies": [
2075
+ "",
2076
+ "",
2077
+ ""
2078
+ ],
2079
+ "num_warps": 4,
2080
+ "num_stages": 1,
2081
+ "indexing": [
2082
+ "pointer",
2083
+ "pointer",
2084
+ "pointer",
2085
+ "pointer"
2086
+ ],
2087
+ "pid_type": "flat"
2088
+ }
2089
+ },
2090
+ {
2091
+ "key": {
2092
+ "intermediate": 8192,
2093
+ "numtokens": 24
2094
+ },
2095
+ "config": {
2096
+ "block_sizes": [
2097
+ 1,
2098
+ 2048
2099
+ ],
2100
+ "loop_orders": [
2101
+ [
2102
+ 0,
2103
+ 1
2104
+ ]
2105
+ ],
2106
+ "flatten_loops": [
2107
+ true
2108
+ ],
2109
+ "l2_groupings": [
2110
+ 32
2111
+ ],
2112
+ "range_unroll_factors": [
2113
+ 0
2114
+ ],
2115
+ "range_warp_specializes": [],
2116
+ "range_num_stages": [
2117
+ 0
2118
+ ],
2119
+ "range_multi_buffers": [
2120
+ null
2121
+ ],
2122
+ "range_flattens": [
2123
+ null
2124
+ ],
2125
+ "load_eviction_policies": [
2126
+ "",
2127
+ "last",
2128
+ "last"
2129
+ ],
2130
+ "num_warps": 32,
2131
+ "num_stages": 5,
2132
+ "indexing": [
2133
+ "pointer",
2134
+ "pointer",
2135
+ "pointer",
2136
+ "tensor_descriptor"
2137
+ ],
2138
+ "pid_type": "flat"
2139
+ }
2140
+ },
2141
+ {
2142
+ "key": {
2143
+ "intermediate": 11008,
2144
+ "numtokens": 24
2145
+ },
2146
+ "config": {
2147
+ "block_sizes": [
2148
+ 1,
2149
+ 1024
2150
+ ],
2151
+ "loop_orders": [
2152
+ [
2153
+ 1,
2154
+ 0
2155
+ ]
2156
+ ],
2157
+ "flatten_loops": [
2158
+ false
2159
+ ],
2160
+ "l2_groupings": [
2161
+ 64
2162
+ ],
2163
+ "range_unroll_factors": [
2164
+ 0
2165
+ ],
2166
+ "range_warp_specializes": [],
2167
+ "range_num_stages": [
2168
+ 0
2169
+ ],
2170
+ "range_multi_buffers": [
2171
+ null
2172
+ ],
2173
+ "range_flattens": [
2174
+ null
2175
+ ],
2176
+ "load_eviction_policies": [
2177
+ "last",
2178
+ "",
2179
+ ""
2180
+ ],
2181
+ "num_warps": 2,
2182
+ "num_stages": 2,
2183
+ "indexing": [
2184
+ "pointer",
2185
+ "pointer",
2186
+ "pointer",
2187
+ "pointer"
2188
+ ],
2189
+ "pid_type": "flat"
2190
+ }
2191
+ },
2192
+ {
2193
+ "key": {
2194
+ "intermediate": 14336,
2195
+ "numtokens": 24
2196
+ },
2197
+ "config": {
2198
+ "block_sizes": [
2199
+ 8,
2200
+ 512
2201
+ ],
2202
+ "loop_orders": [
2203
+ [
2204
+ 0,
2205
+ 1
2206
+ ]
2207
+ ],
2208
+ "flatten_loops": [
2209
+ true
2210
+ ],
2211
+ "l2_groupings": [
2212
+ 4
2213
+ ],
2214
+ "range_unroll_factors": [
2215
+ 0
2216
+ ],
2217
+ "range_warp_specializes": [],
2218
+ "range_num_stages": [
2219
+ 0
2220
+ ],
2221
+ "range_multi_buffers": [
2222
+ null
2223
+ ],
2224
+ "range_flattens": [
2225
+ null
2226
+ ],
2227
+ "load_eviction_policies": [
2228
+ "last",
2229
+ "first",
2230
+ "first"
2231
+ ],
2232
+ "num_warps": 32,
2233
+ "num_stages": 3,
2234
+ "indexing": [
2235
+ "pointer",
2236
+ "tensor_descriptor",
2237
+ "pointer",
2238
+ "tensor_descriptor"
2239
+ ],
2240
+ "pid_type": "flat"
2241
+ }
2242
+ },
2243
+ {
2244
+ "key": {
2245
+ "intermediate": 2048,
2246
+ "numtokens": 32
2247
+ },
2248
+ "config": {
2249
+ "block_sizes": [
2250
+ 32,
2251
+ 16
2252
+ ],
2253
+ "loop_orders": [
2254
+ [
2255
+ 0,
2256
+ 1
2257
+ ]
2258
+ ],
2259
+ "flatten_loops": [
2260
+ true
2261
+ ],
2262
+ "l2_groupings": [
2263
+ 1
2264
+ ],
2265
+ "range_unroll_factors": [
2266
+ 0
2267
+ ],
2268
+ "range_warp_specializes": [],
2269
+ "range_num_stages": [
2270
+ 0
2271
+ ],
2272
+ "range_multi_buffers": [
2273
+ null
2274
+ ],
2275
+ "range_flattens": [
2276
+ null
2277
+ ],
2278
+ "load_eviction_policies": [
2279
+ "",
2280
+ "",
2281
+ ""
2282
+ ],
2283
+ "num_warps": 4,
2284
+ "num_stages": 1,
2285
+ "indexing": [
2286
+ "pointer",
2287
+ "pointer",
2288
+ "pointer",
2289
+ "pointer"
2290
+ ],
2291
+ "pid_type": "flat"
2292
+ }
2293
+ },
2294
+ {
2295
+ "key": {
2296
+ "intermediate": 2880,
2297
+ "numtokens": 32
2298
+ },
2299
+ "config": {
2300
+ "block_sizes": [
2301
+ 4,
2302
+ 256
2303
+ ],
2304
+ "loop_orders": [
2305
+ [
2306
+ 0,
2307
+ 1
2308
+ ]
2309
+ ],
2310
+ "flatten_loops": [
2311
+ true
2312
+ ],
2313
+ "l2_groupings": [
2314
+ 1
2315
+ ],
2316
+ "range_unroll_factors": [
2317
+ 0
2318
+ ],
2319
+ "range_warp_specializes": [],
2320
+ "range_num_stages": [
2321
+ 0
2322
+ ],
2323
+ "range_multi_buffers": [
2324
+ null
2325
+ ],
2326
+ "range_flattens": [
2327
+ null
2328
+ ],
2329
+ "load_eviction_policies": [
2330
+ "",
2331
+ "",
2332
+ ""
2333
+ ],
2334
+ "num_warps": 4,
2335
+ "num_stages": 1,
2336
+ "indexing": [
2337
+ "pointer",
2338
+ "pointer",
2339
+ "pointer",
2340
+ "pointer"
2341
+ ],
2342
+ "pid_type": "flat"
2343
+ }
2344
+ },
2345
+ {
2346
+ "key": {
2347
+ "intermediate": 4096,
2348
+ "numtokens": 32
2349
+ },
2350
+ "config": {
2351
+ "block_sizes": [
2352
+ 4,
2353
+ 4096
2354
+ ],
2355
+ "loop_orders": [
2356
+ [
2357
+ 0,
2358
+ 1
2359
+ ]
2360
+ ],
2361
+ "flatten_loops": [
2362
+ true
2363
+ ],
2364
+ "l2_groupings": [
2365
+ 16
2366
+ ],
2367
+ "range_unroll_factors": [
2368
+ 0
2369
+ ],
2370
+ "range_warp_specializes": [],
2371
+ "range_num_stages": [
2372
+ 0
2373
+ ],
2374
+ "range_multi_buffers": [
2375
+ null
2376
+ ],
2377
+ "range_flattens": [
2378
+ null
2379
+ ],
2380
+ "load_eviction_policies": [
2381
+ "first",
2382
+ "last",
2383
+ ""
2384
+ ],
2385
+ "num_warps": 32,
2386
+ "num_stages": 5,
2387
+ "indexing": [
2388
+ "pointer",
2389
+ "tensor_descriptor",
2390
+ "pointer",
2391
+ "pointer"
2392
+ ],
2393
+ "pid_type": "flat"
2394
+ }
2395
+ },
2396
+ {
2397
+ "key": {
2398
+ "intermediate": 8192,
2399
+ "numtokens": 32
2400
+ },
2401
+ "config": {
2402
+ "block_sizes": [
2403
+ 4,
2404
+ 1024
2405
+ ],
2406
+ "loop_orders": [
2407
+ [
2408
+ 0,
2409
+ 1
2410
+ ]
2411
+ ],
2412
+ "flatten_loops": [
2413
+ true
2414
+ ],
2415
+ "l2_groupings": [
2416
+ 2
2417
+ ],
2418
+ "range_unroll_factors": [
2419
+ 0
2420
+ ],
2421
+ "range_warp_specializes": [],
2422
+ "range_num_stages": [
2423
+ 0
2424
+ ],
2425
+ "range_multi_buffers": [
2426
+ null
2427
+ ],
2428
+ "range_flattens": [
2429
+ null
2430
+ ],
2431
+ "load_eviction_policies": [
2432
+ "",
2433
+ "last",
2434
+ ""
2435
+ ],
2436
+ "num_warps": 2,
2437
+ "num_stages": 3,
2438
+ "indexing": [
2439
+ "tensor_descriptor",
2440
+ "tensor_descriptor",
2441
+ "pointer",
2442
+ "tensor_descriptor"
2443
+ ],
2444
+ "pid_type": "flat"
2445
+ }
2446
+ },
2447
+ {
2448
+ "key": {
2449
+ "intermediate": 11008,
2450
+ "numtokens": 32
2451
+ },
2452
+ "config": {
2453
+ "block_sizes": [
2454
+ 2,
2455
+ 2048
2456
+ ],
2457
+ "loop_orders": [
2458
+ [
2459
+ 0,
2460
+ 1
2461
+ ]
2462
+ ],
2463
+ "flatten_loops": [
2464
+ true
2465
+ ],
2466
+ "l2_groupings": [
2467
+ 1
2468
+ ],
2469
+ "range_unroll_factors": [
2470
+ 0
2471
+ ],
2472
+ "range_warp_specializes": [],
2473
+ "range_num_stages": [
2474
+ 0
2475
+ ],
2476
+ "range_multi_buffers": [
2477
+ null
2478
+ ],
2479
+ "range_flattens": [
2480
+ null
2481
+ ],
2482
+ "load_eviction_policies": [
2483
+ "",
2484
+ "",
2485
+ ""
2486
+ ],
2487
+ "num_warps": 8,
2488
+ "num_stages": 1,
2489
+ "indexing": [
2490
+ "pointer",
2491
+ "pointer",
2492
+ "pointer",
2493
+ "pointer"
2494
+ ],
2495
+ "pid_type": "flat"
2496
+ }
2497
+ },
2498
+ {
2499
+ "key": {
2500
+ "intermediate": 14336,
2501
+ "numtokens": 32
2502
+ },
2503
+ "config": {
2504
+ "block_sizes": [
2505
+ 1,
2506
+ 512
2507
+ ],
2508
+ "loop_orders": [
2509
+ [
2510
+ 0,
2511
+ 1
2512
+ ]
2513
+ ],
2514
+ "flatten_loops": [
2515
+ true
2516
+ ],
2517
+ "l2_groupings": [
2518
+ 64
2519
+ ],
2520
+ "range_unroll_factors": [
2521
+ 0
2522
+ ],
2523
+ "range_warp_specializes": [],
2524
+ "range_num_stages": [
2525
+ 0
2526
+ ],
2527
+ "range_multi_buffers": [
2528
+ null
2529
+ ],
2530
+ "range_flattens": [
2531
+ null
2532
+ ],
2533
+ "load_eviction_policies": [
2534
+ "first",
2535
+ "",
2536
+ ""
2537
+ ],
2538
+ "num_warps": 4,
2539
+ "num_stages": 3,
2540
+ "indexing": [
2541
+ "pointer",
2542
+ "tensor_descriptor",
2543
+ "pointer",
2544
+ "pointer"
2545
+ ],
2546
+ "pid_type": "flat"
2547
+ }
2548
+ },
2549
+ {
2550
+ "key": {
2551
+ "intermediate": 2048,
2552
+ "numtokens": 40
2553
+ },
2554
+ "config": {
2555
+ "block_sizes": [
2556
+ 32,
2557
+ 32
2558
+ ],
2559
+ "loop_orders": [
2560
+ [
2561
+ 0,
2562
+ 1
2563
+ ]
2564
+ ],
2565
+ "flatten_loops": [
2566
+ true
2567
+ ],
2568
+ "l2_groupings": [
2569
+ 1
2570
+ ],
2571
+ "range_unroll_factors": [
2572
+ 0
2573
+ ],
2574
+ "range_warp_specializes": [],
2575
+ "range_num_stages": [
2576
+ 0
2577
+ ],
2578
+ "range_multi_buffers": [
2579
+ null
2580
+ ],
2581
+ "range_flattens": [
2582
+ null
2583
+ ],
2584
+ "load_eviction_policies": [
2585
+ "",
2586
+ "",
2587
+ ""
2588
+ ],
2589
+ "num_warps": 4,
2590
+ "num_stages": 1,
2591
+ "indexing": [
2592
+ "pointer",
2593
+ "pointer",
2594
+ "pointer",
2595
+ "pointer"
2596
+ ],
2597
+ "pid_type": "flat"
2598
+ }
2599
+ },
2600
+ {
2601
+ "key": {
2602
+ "intermediate": 2880,
2603
+ "numtokens": 40
2604
+ },
2605
+ "config": {
2606
+ "block_sizes": [
2607
+ 1,
2608
+ 4096
2609
+ ],
2610
+ "loop_orders": [
2611
+ [
2612
+ 1,
2613
+ 0
2614
+ ]
2615
+ ],
2616
+ "flatten_loops": [
2617
+ false
2618
+ ],
2619
+ "l2_groupings": [
2620
+ 32
2621
+ ],
2622
+ "range_unroll_factors": [
2623
+ 0
2624
+ ],
2625
+ "range_warp_specializes": [],
2626
+ "range_num_stages": [
2627
+ 0
2628
+ ],
2629
+ "range_multi_buffers": [
2630
+ null
2631
+ ],
2632
+ "range_flattens": [
2633
+ null
2634
+ ],
2635
+ "load_eviction_policies": [
2636
+ "",
2637
+ "last",
2638
+ "last"
2639
+ ],
2640
+ "num_warps": 8,
2641
+ "num_stages": 4,
2642
+ "indexing": [
2643
+ "tensor_descriptor",
2644
+ "pointer",
2645
+ "pointer",
2646
+ "pointer"
2647
+ ],
2648
+ "pid_type": "flat"
2649
+ }
2650
+ },
2651
+ {
2652
+ "key": {
2653
+ "intermediate": 4096,
2654
+ "numtokens": 40
2655
+ },
2656
+ "config": {
2657
+ "block_sizes": [
2658
+ 32,
2659
+ 64
2660
+ ],
2661
+ "loop_orders": [
2662
+ [
2663
+ 0,
2664
+ 1
2665
+ ]
2666
+ ],
2667
+ "flatten_loops": [
2668
+ true
2669
+ ],
2670
+ "l2_groupings": [
2671
+ 1
2672
+ ],
2673
+ "range_unroll_factors": [
2674
+ 0
2675
+ ],
2676
+ "range_warp_specializes": [],
2677
+ "range_num_stages": [
2678
+ 0
2679
+ ],
2680
+ "range_multi_buffers": [
2681
+ null
2682
+ ],
2683
+ "range_flattens": [
2684
+ null
2685
+ ],
2686
+ "load_eviction_policies": [
2687
+ "",
2688
+ "",
2689
+ ""
2690
+ ],
2691
+ "num_warps": 8,
2692
+ "num_stages": 1,
2693
+ "indexing": [
2694
+ "pointer",
2695
+ "pointer",
2696
+ "pointer",
2697
+ "pointer"
2698
+ ],
2699
+ "pid_type": "flat"
2700
+ }
2701
+ },
2702
+ {
2703
+ "key": {
2704
+ "intermediate": 8192,
2705
+ "numtokens": 40
2706
+ },
2707
+ "config": {
2708
+ "block_sizes": [
2709
+ 2,
2710
+ 256
2711
+ ],
2712
+ "loop_orders": [
2713
+ [
2714
+ 0,
2715
+ 1
2716
+ ]
2717
+ ],
2718
+ "flatten_loops": [
2719
+ true
2720
+ ],
2721
+ "l2_groupings": [
2722
+ 16
2723
+ ],
2724
+ "range_unroll_factors": [
2725
+ 0
2726
+ ],
2727
+ "range_warp_specializes": [],
2728
+ "range_num_stages": [
2729
+ 0
2730
+ ],
2731
+ "range_multi_buffers": [
2732
+ null
2733
+ ],
2734
+ "range_flattens": [
2735
+ null
2736
+ ],
2737
+ "load_eviction_policies": [
2738
+ "",
2739
+ "last",
2740
+ "last"
2741
+ ],
2742
+ "num_warps": 2,
2743
+ "num_stages": 2,
2744
+ "indexing": [
2745
+ "pointer",
2746
+ "pointer",
2747
+ "pointer",
2748
+ "tensor_descriptor"
2749
+ ],
2750
+ "pid_type": "flat"
2751
+ }
2752
+ },
2753
+ {
2754
+ "key": {
2755
+ "intermediate": 11008,
2756
+ "numtokens": 40
2757
+ },
2758
+ "config": {
2759
+ "block_sizes": [
2760
+ 16,
2761
+ 256
2762
+ ],
2763
+ "loop_orders": [
2764
+ [
2765
+ 0,
2766
+ 1
2767
+ ]
2768
+ ],
2769
+ "flatten_loops": [
2770
+ true
2771
+ ],
2772
+ "l2_groupings": [
2773
+ 1
2774
+ ],
2775
+ "range_unroll_factors": [
2776
+ 0
2777
+ ],
2778
+ "range_warp_specializes": [],
2779
+ "range_num_stages": [
2780
+ 0
2781
+ ],
2782
+ "range_multi_buffers": [
2783
+ null
2784
+ ],
2785
+ "range_flattens": [
2786
+ null
2787
+ ],
2788
+ "load_eviction_policies": [
2789
+ "",
2790
+ "",
2791
+ ""
2792
+ ],
2793
+ "num_warps": 8,
2794
+ "num_stages": 1,
2795
+ "indexing": [
2796
+ "pointer",
2797
+ "pointer",
2798
+ "pointer",
2799
+ "pointer"
2800
+ ],
2801
+ "pid_type": "flat"
2802
+ }
2803
+ },
2804
+ {
2805
+ "key": {
2806
+ "intermediate": 14336,
2807
+ "numtokens": 40
2808
+ },
2809
+ "config": {
2810
+ "block_sizes": [
2811
+ 4,
2812
+ 1024
2813
+ ],
2814
+ "loop_orders": [
2815
+ [
2816
+ 0,
2817
+ 1
2818
+ ]
2819
+ ],
2820
+ "flatten_loops": [
2821
+ true
2822
+ ],
2823
+ "l2_groupings": [
2824
+ 1
2825
+ ],
2826
+ "range_unroll_factors": [
2827
+ 0
2828
+ ],
2829
+ "range_warp_specializes": [],
2830
+ "range_num_stages": [
2831
+ 1
2832
+ ],
2833
+ "range_multi_buffers": [
2834
+ null
2835
+ ],
2836
+ "range_flattens": [
2837
+ null
2838
+ ],
2839
+ "load_eviction_policies": [
2840
+ "first",
2841
+ "",
2842
+ "last"
2843
+ ],
2844
+ "num_warps": 16,
2845
+ "num_stages": 5,
2846
+ "indexing": [
2847
+ "tensor_descriptor",
2848
+ "tensor_descriptor",
2849
+ "tensor_descriptor",
2850
+ "tensor_descriptor"
2851
+ ],
2852
+ "pid_type": "persistent_interleaved",
2853
+ "num_sm_multiplier": 32,
2854
+ "maxnreg": 32
2855
+ }
2856
+ },
2857
+ {
2858
+ "key": {
2859
+ "intermediate": 2048,
2860
+ "numtokens": 48
2861
+ },
2862
+ "config": {
2863
+ "block_sizes": [
2864
+ 32,
2865
+ 32
2866
+ ],
2867
+ "loop_orders": [
2868
+ [
2869
+ 0,
2870
+ 1
2871
+ ]
2872
+ ],
2873
+ "flatten_loops": [
2874
+ true
2875
+ ],
2876
+ "l2_groupings": [
2877
+ 1
2878
+ ],
2879
+ "range_unroll_factors": [
2880
+ 0
2881
+ ],
2882
+ "range_warp_specializes": [],
2883
+ "range_num_stages": [
2884
+ 0
2885
+ ],
2886
+ "range_multi_buffers": [
2887
+ null
2888
+ ],
2889
+ "range_flattens": [
2890
+ null
2891
+ ],
2892
+ "load_eviction_policies": [
2893
+ "",
2894
+ "",
2895
+ ""
2896
+ ],
2897
+ "num_warps": 4,
2898
+ "num_stages": 1,
2899
+ "indexing": [
2900
+ "pointer",
2901
+ "pointer",
2902
+ "pointer",
2903
+ "pointer"
2904
+ ],
2905
+ "pid_type": "flat"
2906
+ }
2907
+ },
2908
+ {
2909
+ "key": {
2910
+ "intermediate": 2880,
2911
+ "numtokens": 48
2912
+ },
2913
+ "config": {
2914
+ "block_sizes": [
2915
+ 16,
2916
+ 64
2917
+ ],
2918
+ "loop_orders": [
2919
+ [
2920
+ 0,
2921
+ 1
2922
+ ]
2923
+ ],
2924
+ "flatten_loops": [
2925
+ true
2926
+ ],
2927
+ "l2_groupings": [
2928
+ 1
2929
+ ],
2930
+ "range_unroll_factors": [
2931
+ 0
2932
+ ],
2933
+ "range_warp_specializes": [],
2934
+ "range_num_stages": [
2935
+ 0
2936
+ ],
2937
+ "range_multi_buffers": [
2938
+ null
2939
+ ],
2940
+ "range_flattens": [
2941
+ null
2942
+ ],
2943
+ "load_eviction_policies": [
2944
+ "",
2945
+ "",
2946
+ ""
2947
+ ],
2948
+ "num_warps": 4,
2949
+ "num_stages": 1,
2950
+ "indexing": [
2951
+ "pointer",
2952
+ "pointer",
2953
+ "pointer",
2954
+ "pointer"
2955
+ ],
2956
+ "pid_type": "flat"
2957
+ }
2958
+ },
2959
+ {
2960
+ "key": {
2961
+ "intermediate": 4096,
2962
+ "numtokens": 48
2963
+ },
2964
+ "config": {
2965
+ "block_sizes": [
2966
+ 32,
2967
+ 64
2968
+ ],
2969
+ "loop_orders": [
2970
+ [
2971
+ 0,
2972
+ 1
2973
+ ]
2974
+ ],
2975
+ "flatten_loops": [
2976
+ true
2977
+ ],
2978
+ "l2_groupings": [
2979
+ 1
2980
+ ],
2981
+ "range_unroll_factors": [
2982
+ 0
2983
+ ],
2984
+ "range_warp_specializes": [],
2985
+ "range_num_stages": [
2986
+ 0
2987
+ ],
2988
+ "range_multi_buffers": [
2989
+ null
2990
+ ],
2991
+ "range_flattens": [
2992
+ null
2993
+ ],
2994
+ "load_eviction_policies": [
2995
+ "",
2996
+ "",
2997
+ ""
2998
+ ],
2999
+ "num_warps": 8,
3000
+ "num_stages": 1,
3001
+ "indexing": [
3002
+ "pointer",
3003
+ "pointer",
3004
+ "pointer",
3005
+ "pointer"
3006
+ ],
3007
+ "pid_type": "flat"
3008
+ }
3009
+ },
3010
+ {
3011
+ "key": {
3012
+ "intermediate": 8192,
3013
+ "numtokens": 48
3014
+ },
3015
+ "config": {
3016
+ "block_sizes": [
3017
+ 1,
3018
+ 4096
3019
+ ],
3020
+ "loop_orders": [
3021
+ [
3022
+ 0,
3023
+ 1
3024
+ ]
3025
+ ],
3026
+ "flatten_loops": [
3027
+ true
3028
+ ],
3029
+ "l2_groupings": [
3030
+ 2
3031
+ ],
3032
+ "range_unroll_factors": [
3033
+ 0
3034
+ ],
3035
+ "range_warp_specializes": [],
3036
+ "range_num_stages": [
3037
+ 0
3038
+ ],
3039
+ "range_multi_buffers": [
3040
+ null
3041
+ ],
3042
+ "range_flattens": [
3043
+ null
3044
+ ],
3045
+ "load_eviction_policies": [
3046
+ "first",
3047
+ "",
3048
+ "last"
3049
+ ],
3050
+ "num_warps": 4,
3051
+ "num_stages": 2,
3052
+ "indexing": [
3053
+ "pointer",
3054
+ "tensor_descriptor",
3055
+ "tensor_descriptor",
3056
+ "pointer"
3057
+ ],
3058
+ "pid_type": "flat"
3059
+ }
3060
+ },
3061
+ {
3062
+ "key": {
3063
+ "intermediate": 11008,
3064
+ "numtokens": 48
3065
+ },
3066
+ "config": {
3067
+ "block_sizes": [
3068
+ 16,
3069
+ 256
3070
+ ],
3071
+ "loop_orders": [
3072
+ [
3073
+ 0,
3074
+ 1
3075
+ ]
3076
+ ],
3077
+ "flatten_loops": [
3078
+ true
3079
+ ],
3080
+ "l2_groupings": [
3081
+ 1
3082
+ ],
3083
+ "range_unroll_factors": [
3084
+ 0
3085
+ ],
3086
+ "range_warp_specializes": [],
3087
+ "range_num_stages": [
3088
+ 0
3089
+ ],
3090
+ "range_multi_buffers": [
3091
+ null
3092
+ ],
3093
+ "range_flattens": [
3094
+ null
3095
+ ],
3096
+ "load_eviction_policies": [
3097
+ "",
3098
+ "",
3099
+ ""
3100
+ ],
3101
+ "num_warps": 8,
3102
+ "num_stages": 1,
3103
+ "indexing": [
3104
+ "pointer",
3105
+ "pointer",
3106
+ "pointer",
3107
+ "pointer"
3108
+ ],
3109
+ "pid_type": "flat"
3110
+ }
3111
+ },
3112
+ {
3113
+ "key": {
3114
+ "intermediate": 14336,
3115
+ "numtokens": 48
3116
+ },
3117
+ "config": {
3118
+ "block_sizes": [
3119
+ 32,
3120
+ 256
3121
+ ],
3122
+ "loop_orders": [
3123
+ [
3124
+ 0,
3125
+ 1
3126
+ ]
3127
+ ],
3128
+ "flatten_loops": [
3129
+ true
3130
+ ],
3131
+ "l2_groupings": [
3132
+ 1
3133
+ ],
3134
+ "range_unroll_factors": [
3135
+ 0
3136
+ ],
3137
+ "range_warp_specializes": [],
3138
+ "range_num_stages": [
3139
+ 0
3140
+ ],
3141
+ "range_multi_buffers": [
3142
+ null
3143
+ ],
3144
+ "range_flattens": [
3145
+ null
3146
+ ],
3147
+ "load_eviction_policies": [
3148
+ "",
3149
+ "",
3150
+ ""
3151
+ ],
3152
+ "num_warps": 8,
3153
+ "num_stages": 1,
3154
+ "indexing": [
3155
+ "pointer",
3156
+ "pointer",
3157
+ "pointer",
3158
+ "pointer"
3159
+ ],
3160
+ "pid_type": "flat"
3161
+ }
3162
+ },
3163
+ {
3164
+ "key": {
3165
+ "intermediate": 2048,
3166
+ "numtokens": 56
3167
+ },
3168
+ "config": {
3169
+ "block_sizes": [
3170
+ 32,
3171
+ 32
3172
+ ],
3173
+ "loop_orders": [
3174
+ [
3175
+ 0,
3176
+ 1
3177
+ ]
3178
+ ],
3179
+ "flatten_loops": [
3180
+ true
3181
+ ],
3182
+ "l2_groupings": [
3183
+ 1
3184
+ ],
3185
+ "range_unroll_factors": [
3186
+ 0
3187
+ ],
3188
+ "range_warp_specializes": [],
3189
+ "range_num_stages": [
3190
+ 0
3191
+ ],
3192
+ "range_multi_buffers": [
3193
+ null
3194
+ ],
3195
+ "range_flattens": [
3196
+ null
3197
+ ],
3198
+ "load_eviction_policies": [
3199
+ "",
3200
+ "",
3201
+ ""
3202
+ ],
3203
+ "num_warps": 4,
3204
+ "num_stages": 1,
3205
+ "indexing": [
3206
+ "pointer",
3207
+ "pointer",
3208
+ "pointer",
3209
+ "pointer"
3210
+ ],
3211
+ "pid_type": "flat"
3212
+ }
3213
+ },
3214
+ {
3215
+ "key": {
3216
+ "intermediate": 2880,
3217
+ "numtokens": 56
3218
+ },
3219
+ "config": {
3220
+ "block_sizes": [
3221
+ 1,
3222
+ 2048
3223
+ ],
3224
+ "loop_orders": [
3225
+ [
3226
+ 0,
3227
+ 1
3228
+ ]
3229
+ ],
3230
+ "flatten_loops": [
3231
+ true
3232
+ ],
3233
+ "l2_groupings": [
3234
+ 1
3235
+ ],
3236
+ "range_unroll_factors": [
3237
+ 0
3238
+ ],
3239
+ "range_warp_specializes": [],
3240
+ "range_num_stages": [
3241
+ 0
3242
+ ],
3243
+ "range_multi_buffers": [
3244
+ null
3245
+ ],
3246
+ "range_flattens": [
3247
+ null
3248
+ ],
3249
+ "load_eviction_policies": [
3250
+ "",
3251
+ "",
3252
+ ""
3253
+ ],
3254
+ "num_warps": 8,
3255
+ "num_stages": 1,
3256
+ "indexing": [
3257
+ "pointer",
3258
+ "pointer",
3259
+ "pointer",
3260
+ "pointer"
3261
+ ],
3262
+ "pid_type": "flat"
3263
+ }
3264
+ },
3265
+ {
3266
+ "key": {
3267
+ "intermediate": 4096,
3268
+ "numtokens": 56
3269
+ },
3270
+ "config": {
3271
+ "block_sizes": [
3272
+ 32,
3273
+ 64
3274
+ ],
3275
+ "loop_orders": [
3276
+ [
3277
+ 0,
3278
+ 1
3279
+ ]
3280
+ ],
3281
+ "flatten_loops": [
3282
+ true
3283
+ ],
3284
+ "l2_groupings": [
3285
+ 1
3286
+ ],
3287
+ "range_unroll_factors": [
3288
+ 0
3289
+ ],
3290
+ "range_warp_specializes": [],
3291
+ "range_num_stages": [
3292
+ 0
3293
+ ],
3294
+ "range_multi_buffers": [
3295
+ null
3296
+ ],
3297
+ "range_flattens": [
3298
+ null
3299
+ ],
3300
+ "load_eviction_policies": [
3301
+ "",
3302
+ "",
3303
+ ""
3304
+ ],
3305
+ "num_warps": 8,
3306
+ "num_stages": 1,
3307
+ "indexing": [
3308
+ "pointer",
3309
+ "pointer",
3310
+ "pointer",
3311
+ "pointer"
3312
+ ],
3313
+ "pid_type": "flat"
3314
+ }
3315
+ },
3316
+ {
3317
+ "key": {
3318
+ "intermediate": 8192,
3319
+ "numtokens": 56
3320
+ },
3321
+ "config": {
3322
+ "block_sizes": [
3323
+ 32,
3324
+ 128
3325
+ ],
3326
+ "loop_orders": [
3327
+ [
3328
+ 0,
3329
+ 1
3330
+ ]
3331
+ ],
3332
+ "flatten_loops": [
3333
+ true
3334
+ ],
3335
+ "l2_groupings": [
3336
+ 1
3337
+ ],
3338
+ "range_unroll_factors": [
3339
+ 0
3340
+ ],
3341
+ "range_warp_specializes": [],
3342
+ "range_num_stages": [
3343
+ 0
3344
+ ],
3345
+ "range_multi_buffers": [
3346
+ null
3347
+ ],
3348
+ "range_flattens": [
3349
+ null
3350
+ ],
3351
+ "load_eviction_policies": [
3352
+ "",
3353
+ "",
3354
+ ""
3355
+ ],
3356
+ "num_warps": 8,
3357
+ "num_stages": 1,
3358
+ "indexing": [
3359
+ "pointer",
3360
+ "pointer",
3361
+ "pointer",
3362
+ "pointer"
3363
+ ],
3364
+ "pid_type": "flat"
3365
+ }
3366
+ },
3367
+ {
3368
+ "key": {
3369
+ "intermediate": 11008,
3370
+ "numtokens": 56
3371
+ },
3372
+ "config": {
3373
+ "block_sizes": [
3374
+ 1,
3375
+ 8192
3376
+ ],
3377
+ "loop_orders": [
3378
+ [
3379
+ 0,
3380
+ 1
3381
+ ]
3382
+ ],
3383
+ "flatten_loops": [
3384
+ true
3385
+ ],
3386
+ "l2_groupings": [
3387
+ 1
3388
+ ],
3389
+ "range_unroll_factors": [
3390
+ 0
3391
+ ],
3392
+ "range_warp_specializes": [],
3393
+ "range_num_stages": [
3394
+ 0
3395
+ ],
3396
+ "range_multi_buffers": [
3397
+ null
3398
+ ],
3399
+ "range_flattens": [
3400
+ null
3401
+ ],
3402
+ "load_eviction_policies": [
3403
+ "",
3404
+ "",
3405
+ ""
3406
+ ],
3407
+ "num_warps": 8,
3408
+ "num_stages": 1,
3409
+ "indexing": [
3410
+ "pointer",
3411
+ "pointer",
3412
+ "pointer",
3413
+ "pointer"
3414
+ ],
3415
+ "pid_type": "flat"
3416
+ }
3417
+ },
3418
+ {
3419
+ "key": {
3420
+ "intermediate": 14336,
3421
+ "numtokens": 56
3422
+ },
3423
+ "config": {
3424
+ "block_sizes": [
3425
+ 2,
3426
+ 4096
3427
+ ],
3428
+ "loop_orders": [
3429
+ [
3430
+ 0,
3431
+ 1
3432
+ ]
3433
+ ],
3434
+ "flatten_loops": [
3435
+ false
3436
+ ],
3437
+ "l2_groupings": [
3438
+ 32
3439
+ ],
3440
+ "range_unroll_factors": [
3441
+ 0
3442
+ ],
3443
+ "range_warp_specializes": [],
3444
+ "range_num_stages": [
3445
+ 0
3446
+ ],
3447
+ "range_multi_buffers": [
3448
+ null
3449
+ ],
3450
+ "range_flattens": [
3451
+ null
3452
+ ],
3453
+ "load_eviction_policies": [
3454
+ "first",
3455
+ "first",
3456
+ ""
3457
+ ],
3458
+ "num_warps": 2,
3459
+ "num_stages": 4,
3460
+ "indexing": [
3461
+ "tensor_descriptor",
3462
+ "pointer",
3463
+ "tensor_descriptor",
3464
+ "tensor_descriptor"
3465
+ ],
3466
+ "pid_type": "flat"
3467
+ }
3468
+ },
3469
+ {
3470
+ "key": {
3471
+ "intermediate": 2048,
3472
+ "numtokens": 64
3473
+ },
3474
+ "config": {
3475
+ "block_sizes": [
3476
+ 64,
3477
+ 32
3478
+ ],
3479
+ "loop_orders": [
3480
+ [
3481
+ 0,
3482
+ 1
3483
+ ]
3484
+ ],
3485
+ "flatten_loops": [
3486
+ true
3487
+ ],
3488
+ "l2_groupings": [
3489
+ 1
3490
+ ],
3491
+ "range_unroll_factors": [
3492
+ 0
3493
+ ],
3494
+ "range_warp_specializes": [],
3495
+ "range_num_stages": [
3496
+ 0
3497
+ ],
3498
+ "range_multi_buffers": [
3499
+ null
3500
+ ],
3501
+ "range_flattens": [
3502
+ null
3503
+ ],
3504
+ "load_eviction_policies": [
3505
+ "",
3506
+ "",
3507
+ ""
3508
+ ],
3509
+ "num_warps": 8,
3510
+ "num_stages": 1,
3511
+ "indexing": [
3512
+ "pointer",
3513
+ "pointer",
3514
+ "pointer",
3515
+ "pointer"
3516
+ ],
3517
+ "pid_type": "flat"
3518
+ }
3519
+ },
3520
+ {
3521
+ "key": {
3522
+ "intermediate": 2880,
3523
+ "numtokens": 64
3524
+ },
3525
+ "config": {
3526
+ "block_sizes": [
3527
+ 1,
3528
+ 2048
3529
+ ],
3530
+ "loop_orders": [
3531
+ [
3532
+ 0,
3533
+ 1
3534
+ ]
3535
+ ],
3536
+ "flatten_loops": [
3537
+ true
3538
+ ],
3539
+ "l2_groupings": [
3540
+ 1
3541
+ ],
3542
+ "range_unroll_factors": [
3543
+ 0
3544
+ ],
3545
+ "range_warp_specializes": [],
3546
+ "range_num_stages": [
3547
+ 0
3548
+ ],
3549
+ "range_multi_buffers": [
3550
+ null
3551
+ ],
3552
+ "range_flattens": [
3553
+ null
3554
+ ],
3555
+ "load_eviction_policies": [
3556
+ "",
3557
+ "",
3558
+ ""
3559
+ ],
3560
+ "num_warps": 8,
3561
+ "num_stages": 1,
3562
+ "indexing": [
3563
+ "pointer",
3564
+ "pointer",
3565
+ "pointer",
3566
+ "pointer"
3567
+ ],
3568
+ "pid_type": "flat"
3569
+ }
3570
+ },
3571
+ {
3572
+ "key": {
3573
+ "intermediate": 4096,
3574
+ "numtokens": 64
3575
+ },
3576
+ "config": {
3577
+ "block_sizes": [
3578
+ 64,
3579
+ 32
3580
+ ],
3581
+ "loop_orders": [
3582
+ [
3583
+ 0,
3584
+ 1
3585
+ ]
3586
+ ],
3587
+ "flatten_loops": [
3588
+ true
3589
+ ],
3590
+ "l2_groupings": [
3591
+ 1
3592
+ ],
3593
+ "range_unroll_factors": [
3594
+ 0
3595
+ ],
3596
+ "range_warp_specializes": [],
3597
+ "range_num_stages": [
3598
+ 0
3599
+ ],
3600
+ "range_multi_buffers": [
3601
+ null
3602
+ ],
3603
+ "range_flattens": [
3604
+ null
3605
+ ],
3606
+ "load_eviction_policies": [
3607
+ "",
3608
+ "",
3609
+ ""
3610
+ ],
3611
+ "num_warps": 8,
3612
+ "num_stages": 1,
3613
+ "indexing": [
3614
+ "pointer",
3615
+ "pointer",
3616
+ "pointer",
3617
+ "pointer"
3618
+ ],
3619
+ "pid_type": "flat"
3620
+ }
3621
+ },
3622
+ {
3623
+ "key": {
3624
+ "intermediate": 8192,
3625
+ "numtokens": 64
3626
+ },
3627
+ "config": {
3628
+ "block_sizes": [
3629
+ 64,
3630
+ 64
3631
+ ],
3632
+ "loop_orders": [
3633
+ [
3634
+ 0,
3635
+ 1
3636
+ ]
3637
+ ],
3638
+ "flatten_loops": [
3639
+ true
3640
+ ],
3641
+ "l2_groupings": [
3642
+ 1
3643
+ ],
3644
+ "range_unroll_factors": [
3645
+ 0
3646
+ ],
3647
+ "range_warp_specializes": [],
3648
+ "range_num_stages": [
3649
+ 0
3650
+ ],
3651
+ "range_multi_buffers": [
3652
+ null
3653
+ ],
3654
+ "range_flattens": [
3655
+ null
3656
+ ],
3657
+ "load_eviction_policies": [
3658
+ "",
3659
+ "",
3660
+ ""
3661
+ ],
3662
+ "num_warps": 8,
3663
+ "num_stages": 1,
3664
+ "indexing": [
3665
+ "pointer",
3666
+ "pointer",
3667
+ "pointer",
3668
+ "pointer"
3669
+ ],
3670
+ "pid_type": "flat"
3671
+ }
3672
+ },
3673
+ {
3674
+ "key": {
3675
+ "intermediate": 11008,
3676
+ "numtokens": 64
3677
+ },
3678
+ "config": {
3679
+ "block_sizes": [
3680
+ 1,
3681
+ 8192
3682
+ ],
3683
+ "loop_orders": [
3684
+ [
3685
+ 0,
3686
+ 1
3687
+ ]
3688
+ ],
3689
+ "flatten_loops": [
3690
+ true
3691
+ ],
3692
+ "l2_groupings": [
3693
+ 1
3694
+ ],
3695
+ "range_unroll_factors": [
3696
+ 0
3697
+ ],
3698
+ "range_warp_specializes": [],
3699
+ "range_num_stages": [
3700
+ 0
3701
+ ],
3702
+ "range_multi_buffers": [
3703
+ null
3704
+ ],
3705
+ "range_flattens": [
3706
+ null
3707
+ ],
3708
+ "load_eviction_policies": [
3709
+ "",
3710
+ "",
3711
+ ""
3712
+ ],
3713
+ "num_warps": 8,
3714
+ "num_stages": 1,
3715
+ "indexing": [
3716
+ "pointer",
3717
+ "pointer",
3718
+ "pointer",
3719
+ "pointer"
3720
+ ],
3721
+ "pid_type": "flat"
3722
+ }
3723
+ },
3724
+ {
3725
+ "key": {
3726
+ "intermediate": 14336,
3727
+ "numtokens": 64
3728
+ },
3729
+ "config": {
3730
+ "block_sizes": [
3731
+ 16,
3732
+ 512
3733
+ ],
3734
+ "loop_orders": [
3735
+ [
3736
+ 0,
3737
+ 1
3738
+ ]
3739
+ ],
3740
+ "flatten_loops": [
3741
+ true
3742
+ ],
3743
+ "l2_groupings": [
3744
+ 16
3745
+ ],
3746
+ "range_unroll_factors": [
3747
+ 0
3748
+ ],
3749
+ "range_warp_specializes": [],
3750
+ "range_num_stages": [
3751
+ 0
3752
+ ],
3753
+ "range_multi_buffers": [
3754
+ null
3755
+ ],
3756
+ "range_flattens": [
3757
+ null
3758
+ ],
3759
+ "load_eviction_policies": [
3760
+ "",
3761
+ "first",
3762
+ ""
3763
+ ],
3764
+ "num_warps": 4,
3765
+ "num_stages": 1,
3766
+ "indexing": [
3767
+ "pointer",
3768
+ "tensor_descriptor",
3769
+ "tensor_descriptor",
3770
+ "tensor_descriptor"
3771
+ ],
3772
+ "pid_type": "flat"
3773
+ }
3774
+ },
3775
+ {
3776
+ "key": {
3777
+ "intermediate": 2048,
3778
+ "numtokens": 72
3779
+ },
3780
+ "config": {
3781
+ "block_sizes": [
3782
+ 64,
3783
+ 32
3784
+ ],
3785
+ "loop_orders": [
3786
+ [
3787
+ 0,
3788
+ 1
3789
+ ]
3790
+ ],
3791
+ "flatten_loops": [
3792
+ true
3793
+ ],
3794
+ "l2_groupings": [
3795
+ 1
3796
+ ],
3797
+ "range_unroll_factors": [
3798
+ 0
3799
+ ],
3800
+ "range_warp_specializes": [],
3801
+ "range_num_stages": [
3802
+ 0
3803
+ ],
3804
+ "range_multi_buffers": [
3805
+ null
3806
+ ],
3807
+ "range_flattens": [
3808
+ null
3809
+ ],
3810
+ "load_eviction_policies": [
3811
+ "",
3812
+ "",
3813
+ ""
3814
+ ],
3815
+ "num_warps": 8,
3816
+ "num_stages": 1,
3817
+ "indexing": [
3818
+ "pointer",
3819
+ "pointer",
3820
+ "pointer",
3821
+ "pointer"
3822
+ ],
3823
+ "pid_type": "flat"
3824
+ }
3825
+ },
3826
+ {
3827
+ "key": {
3828
+ "intermediate": 2880,
3829
+ "numtokens": 72
3830
+ },
3831
+ "config": {
3832
+ "block_sizes": [
3833
+ 32,
3834
+ 64
3835
+ ],
3836
+ "loop_orders": [
3837
+ [
3838
+ 0,
3839
+ 1
3840
+ ]
3841
+ ],
3842
+ "flatten_loops": [
3843
+ true
3844
+ ],
3845
+ "l2_groupings": [
3846
+ 1
3847
+ ],
3848
+ "range_unroll_factors": [
3849
+ 0
3850
+ ],
3851
+ "range_warp_specializes": [],
3852
+ "range_num_stages": [
3853
+ 0
3854
+ ],
3855
+ "range_multi_buffers": [
3856
+ null
3857
+ ],
3858
+ "range_flattens": [
3859
+ null
3860
+ ],
3861
+ "load_eviction_policies": [
3862
+ "",
3863
+ "",
3864
+ ""
3865
+ ],
3866
+ "num_warps": 8,
3867
+ "num_stages": 1,
3868
+ "indexing": [
3869
+ "pointer",
3870
+ "pointer",
3871
+ "pointer",
3872
+ "pointer"
3873
+ ],
3874
+ "pid_type": "flat"
3875
+ }
3876
+ },
3877
+ {
3878
+ "key": {
3879
+ "intermediate": 4096,
3880
+ "numtokens": 72
3881
+ },
3882
+ "config": {
3883
+ "block_sizes": [
3884
+ 1,
3885
+ 1024
3886
+ ],
3887
+ "loop_orders": [
3888
+ [
3889
+ 0,
3890
+ 1
3891
+ ]
3892
+ ],
3893
+ "flatten_loops": [
3894
+ true
3895
+ ],
3896
+ "l2_groupings": [
3897
+ 4
3898
+ ],
3899
+ "range_unroll_factors": [
3900
+ 0
3901
+ ],
3902
+ "range_warp_specializes": [],
3903
+ "range_num_stages": [
3904
+ 0
3905
+ ],
3906
+ "range_multi_buffers": [
3907
+ null
3908
+ ],
3909
+ "range_flattens": [
3910
+ null
3911
+ ],
3912
+ "load_eviction_policies": [
3913
+ "",
3914
+ "",
3915
+ "first"
3916
+ ],
3917
+ "num_warps": 16,
3918
+ "num_stages": 2,
3919
+ "indexing": [
3920
+ "tensor_descriptor",
3921
+ "pointer",
3922
+ "pointer",
3923
+ "tensor_descriptor"
3924
+ ],
3925
+ "pid_type": "flat"
3926
+ }
3927
+ },
3928
+ {
3929
+ "key": {
3930
+ "intermediate": 8192,
3931
+ "numtokens": 72
3932
+ },
3933
+ "config": {
3934
+ "block_sizes": [
3935
+ 64,
3936
+ 128
3937
+ ],
3938
+ "loop_orders": [
3939
+ [
3940
+ 0,
3941
+ 1
3942
+ ]
3943
+ ],
3944
+ "flatten_loops": [
3945
+ true
3946
+ ],
3947
+ "l2_groupings": [
3948
+ 1
3949
+ ],
3950
+ "range_unroll_factors": [
3951
+ 0
3952
+ ],
3953
+ "range_warp_specializes": [],
3954
+ "range_num_stages": [
3955
+ 0
3956
+ ],
3957
+ "range_multi_buffers": [
3958
+ null
3959
+ ],
3960
+ "range_flattens": [
3961
+ null
3962
+ ],
3963
+ "load_eviction_policies": [
3964
+ "",
3965
+ "",
3966
+ ""
3967
+ ],
3968
+ "num_warps": 8,
3969
+ "num_stages": 1,
3970
+ "indexing": [
3971
+ "pointer",
3972
+ "pointer",
3973
+ "pointer",
3974
+ "pointer"
3975
+ ],
3976
+ "pid_type": "flat"
3977
+ }
3978
+ },
3979
+ {
3980
+ "key": {
3981
+ "intermediate": 11008,
3982
+ "numtokens": 72
3983
+ },
3984
+ "config": {
3985
+ "block_sizes": [
3986
+ 4,
3987
+ 256
3988
+ ],
3989
+ "loop_orders": [
3990
+ [
3991
+ 0,
3992
+ 1
3993
+ ]
3994
+ ],
3995
+ "flatten_loops": [
3996
+ true
3997
+ ],
3998
+ "l2_groupings": [
3999
+ 2
4000
+ ],
4001
+ "range_unroll_factors": [
4002
+ 0
4003
+ ],
4004
+ "range_warp_specializes": [],
4005
+ "range_num_stages": [
4006
+ 0
4007
+ ],
4008
+ "range_multi_buffers": [
4009
+ null
4010
+ ],
4011
+ "range_flattens": [
4012
+ null
4013
+ ],
4014
+ "load_eviction_policies": [
4015
+ "first",
4016
+ "last",
4017
+ "last"
4018
+ ],
4019
+ "num_warps": 32,
4020
+ "num_stages": 5,
4021
+ "indexing": [
4022
+ "pointer",
4023
+ "pointer",
4024
+ "tensor_descriptor",
4025
+ "tensor_descriptor"
4026
+ ],
4027
+ "pid_type": "flat"
4028
+ }
4029
+ },
4030
+ {
4031
+ "key": {
4032
+ "intermediate": 14336,
4033
+ "numtokens": 72
4034
+ },
4035
+ "config": {
4036
+ "block_sizes": [
4037
+ 32,
4038
+ 32
4039
+ ],
4040
+ "loop_orders": [
4041
+ [
4042
+ 0,
4043
+ 1
4044
+ ]
4045
+ ],
4046
+ "flatten_loops": [
4047
+ true
4048
+ ],
4049
+ "l2_groupings": [
4050
+ 2
4051
+ ],
4052
+ "range_unroll_factors": [
4053
+ 0
4054
+ ],
4055
+ "range_warp_specializes": [],
4056
+ "range_num_stages": [
4057
+ 0
4058
+ ],
4059
+ "range_multi_buffers": [
4060
+ null
4061
+ ],
4062
+ "range_flattens": [
4063
+ null
4064
+ ],
4065
+ "load_eviction_policies": [
4066
+ "last",
4067
+ "",
4068
+ "last"
4069
+ ],
4070
+ "num_warps": 8,
4071
+ "num_stages": 3,
4072
+ "indexing": [
4073
+ "pointer",
4074
+ "pointer",
4075
+ "tensor_descriptor",
4076
+ "pointer"
4077
+ ],
4078
+ "pid_type": "flat"
4079
+ }
4080
+ },
4081
+ {
4082
+ "key": {
4083
+ "intermediate": 2048,
4084
+ "numtokens": 80
4085
+ },
4086
+ "config": {
4087
+ "block_sizes": [
4088
+ 64,
4089
+ 32
4090
+ ],
4091
+ "loop_orders": [
4092
+ [
4093
+ 0,
4094
+ 1
4095
+ ]
4096
+ ],
4097
+ "flatten_loops": [
4098
+ true
4099
+ ],
4100
+ "l2_groupings": [
4101
+ 1
4102
+ ],
4103
+ "range_unroll_factors": [
4104
+ 0
4105
+ ],
4106
+ "range_warp_specializes": [],
4107
+ "range_num_stages": [
4108
+ 0
4109
+ ],
4110
+ "range_multi_buffers": [
4111
+ null
4112
+ ],
4113
+ "range_flattens": [
4114
+ null
4115
+ ],
4116
+ "load_eviction_policies": [
4117
+ "",
4118
+ "",
4119
+ ""
4120
+ ],
4121
+ "num_warps": 8,
4122
+ "num_stages": 1,
4123
+ "indexing": [
4124
+ "pointer",
4125
+ "pointer",
4126
+ "pointer",
4127
+ "pointer"
4128
+ ],
4129
+ "pid_type": "flat"
4130
+ }
4131
+ },
4132
+ {
4133
+ "key": {
4134
+ "intermediate": 2880,
4135
+ "numtokens": 80
4136
+ },
4137
+ "config": {
4138
+ "block_sizes": [
4139
+ 32,
4140
+ 64
4141
+ ],
4142
+ "loop_orders": [
4143
+ [
4144
+ 0,
4145
+ 1
4146
+ ]
4147
+ ],
4148
+ "flatten_loops": [
4149
+ true
4150
+ ],
4151
+ "l2_groupings": [
4152
+ 1
4153
+ ],
4154
+ "range_unroll_factors": [
4155
+ 0
4156
+ ],
4157
+ "range_warp_specializes": [],
4158
+ "range_num_stages": [
4159
+ 0
4160
+ ],
4161
+ "range_multi_buffers": [
4162
+ null
4163
+ ],
4164
+ "range_flattens": [
4165
+ null
4166
+ ],
4167
+ "load_eviction_policies": [
4168
+ "",
4169
+ "",
4170
+ ""
4171
+ ],
4172
+ "num_warps": 8,
4173
+ "num_stages": 1,
4174
+ "indexing": [
4175
+ "pointer",
4176
+ "pointer",
4177
+ "pointer",
4178
+ "pointer"
4179
+ ],
4180
+ "pid_type": "flat"
4181
+ }
4182
+ },
4183
+ {
4184
+ "key": {
4185
+ "intermediate": 4096,
4186
+ "numtokens": 80
4187
+ },
4188
+ "config": {
4189
+ "block_sizes": [
4190
+ 64,
4191
+ 64
4192
+ ],
4193
+ "loop_orders": [
4194
+ [
4195
+ 0,
4196
+ 1
4197
+ ]
4198
+ ],
4199
+ "flatten_loops": [
4200
+ true
4201
+ ],
4202
+ "l2_groupings": [
4203
+ 1
4204
+ ],
4205
+ "range_unroll_factors": [
4206
+ 0
4207
+ ],
4208
+ "range_warp_specializes": [],
4209
+ "range_num_stages": [
4210
+ 0
4211
+ ],
4212
+ "range_multi_buffers": [
4213
+ null
4214
+ ],
4215
+ "range_flattens": [
4216
+ null
4217
+ ],
4218
+ "load_eviction_policies": [
4219
+ "",
4220
+ "",
4221
+ ""
4222
+ ],
4223
+ "num_warps": 8,
4224
+ "num_stages": 1,
4225
+ "indexing": [
4226
+ "pointer",
4227
+ "pointer",
4228
+ "pointer",
4229
+ "pointer"
4230
+ ],
4231
+ "pid_type": "flat"
4232
+ }
4233
+ },
4234
+ {
4235
+ "key": {
4236
+ "intermediate": 8192,
4237
+ "numtokens": 80
4238
+ },
4239
+ "config": {
4240
+ "block_sizes": [
4241
+ 4,
4242
+ 128
4243
+ ],
4244
+ "loop_orders": [
4245
+ [
4246
+ 0,
4247
+ 1
4248
+ ]
4249
+ ],
4250
+ "flatten_loops": [
4251
+ true
4252
+ ],
4253
+ "l2_groupings": [
4254
+ 4
4255
+ ],
4256
+ "range_unroll_factors": [
4257
+ 0
4258
+ ],
4259
+ "range_warp_specializes": [],
4260
+ "range_num_stages": [
4261
+ 0
4262
+ ],
4263
+ "range_multi_buffers": [
4264
+ null
4265
+ ],
4266
+ "range_flattens": [
4267
+ null
4268
+ ],
4269
+ "load_eviction_policies": [
4270
+ "last",
4271
+ "last",
4272
+ "last"
4273
+ ],
4274
+ "num_warps": 16,
4275
+ "num_stages": 2,
4276
+ "indexing": [
4277
+ "pointer",
4278
+ "pointer",
4279
+ "pointer",
4280
+ "pointer"
4281
+ ],
4282
+ "pid_type": "flat"
4283
+ }
4284
+ },
4285
+ {
4286
+ "key": {
4287
+ "intermediate": 11008,
4288
+ "numtokens": 80
4289
+ },
4290
+ "config": {
4291
+ "block_sizes": [
4292
+ 1,
4293
+ 4096
4294
+ ],
4295
+ "loop_orders": [
4296
+ [
4297
+ 0,
4298
+ 1
4299
+ ]
4300
+ ],
4301
+ "flatten_loops": [
4302
+ true
4303
+ ],
4304
+ "l2_groupings": [
4305
+ 32
4306
+ ],
4307
+ "range_unroll_factors": [
4308
+ 0
4309
+ ],
4310
+ "range_warp_specializes": [],
4311
+ "range_num_stages": [
4312
+ 0
4313
+ ],
4314
+ "range_multi_buffers": [
4315
+ null
4316
+ ],
4317
+ "range_flattens": [
4318
+ null
4319
+ ],
4320
+ "load_eviction_policies": [
4321
+ "last",
4322
+ "last",
4323
+ ""
4324
+ ],
4325
+ "num_warps": 16,
4326
+ "num_stages": 2,
4327
+ "indexing": [
4328
+ "pointer",
4329
+ "tensor_descriptor",
4330
+ "tensor_descriptor",
4331
+ "tensor_descriptor"
4332
+ ],
4333
+ "pid_type": "flat"
4334
+ }
4335
+ },
4336
+ {
4337
+ "key": {
4338
+ "intermediate": 14336,
4339
+ "numtokens": 80
4340
+ },
4341
+ "config": {
4342
+ "block_sizes": [
4343
+ 2,
4344
+ 2048
4345
+ ],
4346
+ "loop_orders": [
4347
+ [
4348
+ 0,
4349
+ 1
4350
+ ]
4351
+ ],
4352
+ "flatten_loops": [
4353
+ true
4354
+ ],
4355
+ "l2_groupings": [
4356
+ 4
4357
+ ],
4358
+ "range_unroll_factors": [
4359
+ 0
4360
+ ],
4361
+ "range_warp_specializes": [],
4362
+ "range_num_stages": [
4363
+ 0
4364
+ ],
4365
+ "range_multi_buffers": [
4366
+ null
4367
+ ],
4368
+ "range_flattens": [
4369
+ null
4370
+ ],
4371
+ "load_eviction_policies": [
4372
+ "last",
4373
+ "last",
4374
+ ""
4375
+ ],
4376
+ "num_warps": 4,
4377
+ "num_stages": 6,
4378
+ "indexing": [
4379
+ "tensor_descriptor",
4380
+ "pointer",
4381
+ "pointer",
4382
+ "tensor_descriptor"
4383
+ ],
4384
+ "pid_type": "flat"
4385
+ }
4386
+ },
4387
+ {
4388
+ "key": {
4389
+ "intermediate": 2048,
4390
+ "numtokens": 88
4391
+ },
4392
+ "config": {
4393
+ "block_sizes": [
4394
+ 64,
4395
+ 32
4396
+ ],
4397
+ "loop_orders": [
4398
+ [
4399
+ 0,
4400
+ 1
4401
+ ]
4402
+ ],
4403
+ "flatten_loops": [
4404
+ true
4405
+ ],
4406
+ "l2_groupings": [
4407
+ 1
4408
+ ],
4409
+ "range_unroll_factors": [
4410
+ 0
4411
+ ],
4412
+ "range_warp_specializes": [],
4413
+ "range_num_stages": [
4414
+ 0
4415
+ ],
4416
+ "range_multi_buffers": [
4417
+ null
4418
+ ],
4419
+ "range_flattens": [
4420
+ null
4421
+ ],
4422
+ "load_eviction_policies": [
4423
+ "",
4424
+ "",
4425
+ ""
4426
+ ],
4427
+ "num_warps": 8,
4428
+ "num_stages": 1,
4429
+ "indexing": [
4430
+ "pointer",
4431
+ "pointer",
4432
+ "pointer",
4433
+ "pointer"
4434
+ ],
4435
+ "pid_type": "flat"
4436
+ }
4437
+ },
4438
+ {
4439
+ "key": {
4440
+ "intermediate": 2880,
4441
+ "numtokens": 88
4442
+ },
4443
+ "config": {
4444
+ "block_sizes": [
4445
+ 8,
4446
+ 256
4447
+ ],
4448
+ "loop_orders": [
4449
+ [
4450
+ 0,
4451
+ 1
4452
+ ]
4453
+ ],
4454
+ "flatten_loops": [
4455
+ true
4456
+ ],
4457
+ "l2_groupings": [
4458
+ 1
4459
+ ],
4460
+ "range_unroll_factors": [
4461
+ 0
4462
+ ],
4463
+ "range_warp_specializes": [],
4464
+ "range_num_stages": [
4465
+ 0
4466
+ ],
4467
+ "range_multi_buffers": [
4468
+ null
4469
+ ],
4470
+ "range_flattens": [
4471
+ null
4472
+ ],
4473
+ "load_eviction_policies": [
4474
+ "",
4475
+ "",
4476
+ ""
4477
+ ],
4478
+ "num_warps": 8,
4479
+ "num_stages": 1,
4480
+ "indexing": [
4481
+ "pointer",
4482
+ "pointer",
4483
+ "pointer",
4484
+ "pointer"
4485
+ ],
4486
+ "pid_type": "flat"
4487
+ }
4488
+ },
4489
+ {
4490
+ "key": {
4491
+ "intermediate": 4096,
4492
+ "numtokens": 88
4493
+ },
4494
+ "config": {
4495
+ "block_sizes": [
4496
+ 64,
4497
+ 64
4498
+ ],
4499
+ "loop_orders": [
4500
+ [
4501
+ 0,
4502
+ 1
4503
+ ]
4504
+ ],
4505
+ "flatten_loops": [
4506
+ true
4507
+ ],
4508
+ "l2_groupings": [
4509
+ 1
4510
+ ],
4511
+ "range_unroll_factors": [
4512
+ 0
4513
+ ],
4514
+ "range_warp_specializes": [],
4515
+ "range_num_stages": [
4516
+ 0
4517
+ ],
4518
+ "range_multi_buffers": [
4519
+ null
4520
+ ],
4521
+ "range_flattens": [
4522
+ null
4523
+ ],
4524
+ "load_eviction_policies": [
4525
+ "",
4526
+ "",
4527
+ ""
4528
+ ],
4529
+ "num_warps": 8,
4530
+ "num_stages": 1,
4531
+ "indexing": [
4532
+ "pointer",
4533
+ "pointer",
4534
+ "pointer",
4535
+ "pointer"
4536
+ ],
4537
+ "pid_type": "flat"
4538
+ }
4539
+ },
4540
+ {
4541
+ "key": {
4542
+ "intermediate": 8192,
4543
+ "numtokens": 88
4544
+ },
4545
+ "config": {
4546
+ "block_sizes": [
4547
+ 64,
4548
+ 128
4549
+ ],
4550
+ "loop_orders": [
4551
+ [
4552
+ 0,
4553
+ 1
4554
+ ]
4555
+ ],
4556
+ "flatten_loops": [
4557
+ true
4558
+ ],
4559
+ "l2_groupings": [
4560
+ 1
4561
+ ],
4562
+ "range_unroll_factors": [
4563
+ 0
4564
+ ],
4565
+ "range_warp_specializes": [],
4566
+ "range_num_stages": [
4567
+ 0
4568
+ ],
4569
+ "range_multi_buffers": [
4570
+ null
4571
+ ],
4572
+ "range_flattens": [
4573
+ null
4574
+ ],
4575
+ "load_eviction_policies": [
4576
+ "",
4577
+ "",
4578
+ ""
4579
+ ],
4580
+ "num_warps": 8,
4581
+ "num_stages": 1,
4582
+ "indexing": [
4583
+ "pointer",
4584
+ "pointer",
4585
+ "pointer",
4586
+ "pointer"
4587
+ ],
4588
+ "pid_type": "flat"
4589
+ }
4590
+ },
4591
+ {
4592
+ "key": {
4593
+ "intermediate": 11008,
4594
+ "numtokens": 88
4595
+ },
4596
+ "config": {
4597
+ "block_sizes": [
4598
+ 16,
4599
+ 2048
4600
+ ],
4601
+ "loop_orders": [
4602
+ [
4603
+ 0,
4604
+ 1
4605
+ ]
4606
+ ],
4607
+ "flatten_loops": [
4608
+ true
4609
+ ],
4610
+ "l2_groupings": [
4611
+ 2
4612
+ ],
4613
+ "range_unroll_factors": [
4614
+ 0
4615
+ ],
4616
+ "range_warp_specializes": [],
4617
+ "range_num_stages": [
4618
+ 0
4619
+ ],
4620
+ "range_multi_buffers": [
4621
+ null
4622
+ ],
4623
+ "range_flattens": [
4624
+ null
4625
+ ],
4626
+ "load_eviction_policies": [
4627
+ "first",
4628
+ "first",
4629
+ ""
4630
+ ],
4631
+ "num_warps": 32,
4632
+ "num_stages": 2,
4633
+ "indexing": [
4634
+ "tensor_descriptor",
4635
+ "tensor_descriptor",
4636
+ "pointer",
4637
+ "pointer"
4638
+ ],
4639
+ "pid_type": "flat"
4640
+ }
4641
+ },
4642
+ {
4643
+ "key": {
4644
+ "intermediate": 14336,
4645
+ "numtokens": 88
4646
+ },
4647
+ "config": {
4648
+ "block_sizes": [
4649
+ 4,
4650
+ 512
4651
+ ],
4652
+ "loop_orders": [
4653
+ [
4654
+ 0,
4655
+ 1
4656
+ ]
4657
+ ],
4658
+ "flatten_loops": [
4659
+ true
4660
+ ],
4661
+ "l2_groupings": [
4662
+ 16
4663
+ ],
4664
+ "range_unroll_factors": [
4665
+ 0
4666
+ ],
4667
+ "range_warp_specializes": [],
4668
+ "range_num_stages": [
4669
+ 0
4670
+ ],
4671
+ "range_multi_buffers": [
4672
+ null
4673
+ ],
4674
+ "range_flattens": [
4675
+ null
4676
+ ],
4677
+ "load_eviction_policies": [
4678
+ "",
4679
+ "",
4680
+ ""
4681
+ ],
4682
+ "num_warps": 32,
4683
+ "num_stages": 5,
4684
+ "indexing": [
4685
+ "pointer",
4686
+ "pointer",
4687
+ "pointer",
4688
+ "pointer"
4689
+ ],
4690
+ "pid_type": "flat"
4691
+ }
4692
+ },
4693
+ {
4694
+ "key": {
4695
+ "intermediate": 2048,
4696
+ "numtokens": 96
4697
+ },
4698
+ "config": {
4699
+ "block_sizes": [
4700
+ 64,
4701
+ 32
4702
+ ],
4703
+ "loop_orders": [
4704
+ [
4705
+ 0,
4706
+ 1
4707
+ ]
4708
+ ],
4709
+ "flatten_loops": [
4710
+ true
4711
+ ],
4712
+ "l2_groupings": [
4713
+ 1
4714
+ ],
4715
+ "range_unroll_factors": [
4716
+ 0
4717
+ ],
4718
+ "range_warp_specializes": [],
4719
+ "range_num_stages": [
4720
+ 0
4721
+ ],
4722
+ "range_multi_buffers": [
4723
+ null
4724
+ ],
4725
+ "range_flattens": [
4726
+ null
4727
+ ],
4728
+ "load_eviction_policies": [
4729
+ "",
4730
+ "",
4731
+ ""
4732
+ ],
4733
+ "num_warps": 8,
4734
+ "num_stages": 1,
4735
+ "indexing": [
4736
+ "pointer",
4737
+ "pointer",
4738
+ "pointer",
4739
+ "pointer"
4740
+ ],
4741
+ "pid_type": "flat"
4742
+ }
4743
+ },
4744
+ {
4745
+ "key": {
4746
+ "intermediate": 2880,
4747
+ "numtokens": 96
4748
+ },
4749
+ "config": {
4750
+ "block_sizes": [
4751
+ 32,
4752
+ 64
4753
+ ],
4754
+ "loop_orders": [
4755
+ [
4756
+ 0,
4757
+ 1
4758
+ ]
4759
+ ],
4760
+ "flatten_loops": [
4761
+ true
4762
+ ],
4763
+ "l2_groupings": [
4764
+ 1
4765
+ ],
4766
+ "range_unroll_factors": [
4767
+ 0
4768
+ ],
4769
+ "range_warp_specializes": [],
4770
+ "range_num_stages": [
4771
+ 0
4772
+ ],
4773
+ "range_multi_buffers": [
4774
+ null
4775
+ ],
4776
+ "range_flattens": [
4777
+ null
4778
+ ],
4779
+ "load_eviction_policies": [
4780
+ "",
4781
+ "",
4782
+ ""
4783
+ ],
4784
+ "num_warps": 8,
4785
+ "num_stages": 1,
4786
+ "indexing": [
4787
+ "pointer",
4788
+ "pointer",
4789
+ "pointer",
4790
+ "pointer"
4791
+ ],
4792
+ "pid_type": "flat"
4793
+ }
4794
+ },
4795
+ {
4796
+ "key": {
4797
+ "intermediate": 4096,
4798
+ "numtokens": 96
4799
+ },
4800
+ "config": {
4801
+ "block_sizes": [
4802
+ 1,
4803
+ 4096
4804
+ ],
4805
+ "loop_orders": [
4806
+ [
4807
+ 1,
4808
+ 0
4809
+ ]
4810
+ ],
4811
+ "flatten_loops": [
4812
+ false
4813
+ ],
4814
+ "l2_groupings": [
4815
+ 64
4816
+ ],
4817
+ "range_unroll_factors": [
4818
+ 0
4819
+ ],
4820
+ "range_warp_specializes": [],
4821
+ "range_num_stages": [
4822
+ 0
4823
+ ],
4824
+ "range_multi_buffers": [
4825
+ null
4826
+ ],
4827
+ "range_flattens": [
4828
+ null
4829
+ ],
4830
+ "load_eviction_policies": [
4831
+ "first",
4832
+ "last",
4833
+ "last"
4834
+ ],
4835
+ "num_warps": 4,
4836
+ "num_stages": 6,
4837
+ "indexing": [
4838
+ "pointer",
4839
+ "pointer",
4840
+ "tensor_descriptor",
4841
+ "pointer"
4842
+ ],
4843
+ "pid_type": "flat"
4844
+ }
4845
+ },
4846
+ {
4847
+ "key": {
4848
+ "intermediate": 8192,
4849
+ "numtokens": 96
4850
+ },
4851
+ "config": {
4852
+ "block_sizes": [
4853
+ 64,
4854
+ 128
4855
+ ],
4856
+ "loop_orders": [
4857
+ [
4858
+ 0,
4859
+ 1
4860
+ ]
4861
+ ],
4862
+ "flatten_loops": [
4863
+ true
4864
+ ],
4865
+ "l2_groupings": [
4866
+ 1
4867
+ ],
4868
+ "range_unroll_factors": [
4869
+ 0
4870
+ ],
4871
+ "range_warp_specializes": [],
4872
+ "range_num_stages": [
4873
+ 0
4874
+ ],
4875
+ "range_multi_buffers": [
4876
+ null
4877
+ ],
4878
+ "range_flattens": [
4879
+ null
4880
+ ],
4881
+ "load_eviction_policies": [
4882
+ "",
4883
+ "",
4884
+ ""
4885
+ ],
4886
+ "num_warps": 8,
4887
+ "num_stages": 1,
4888
+ "indexing": [
4889
+ "pointer",
4890
+ "pointer",
4891
+ "pointer",
4892
+ "pointer"
4893
+ ],
4894
+ "pid_type": "flat"
4895
+ }
4896
+ },
4897
+ {
4898
+ "key": {
4899
+ "intermediate": 11008,
4900
+ "numtokens": 96
4901
+ },
This file is too large to show in full.
vllm/kernels/helion/configs/silu_mul_fp8/nvidia_h200.json
+15666
-13821
@@ -1,13866 +1,15711 @@
1
-{
2
- "intermediate_2048_numtokens_256": {
3
- "block_sizes": [
4
- 64,
5
- 32
6
- ],
7
- "loop_orders": [
8
- [
9
- 0,
10
- 1
11
- ]
12
- ],
13
- "flatten_loops": [
14
- true
15
- ],
16
- "l2_groupings": [
17
- 1
18
- ],
19
- "range_unroll_factors": [
20
- 0
21
- ],
22
- "range_warp_specializes": [],
23
- "range_num_stages": [
24
- 0
25
- ],
26
- "range_multi_buffers": [
27
- null
28
- ],
29
- "range_flattens": [
30
- null
31
- ],
32
- "load_eviction_policies": [
33
- "",
34
- "",
35
- ""
36
- ],
37
- "num_warps": 8,
38
- "num_stages": 1,
39
- "indexing": [
40
- "pointer",
41
- "pointer",
42
- "pointer",
43
- "pointer"
44
- ],
45
- "pid_type": "flat"
46
- },
47
- "intermediate_4096_numtokens_256": {
48
- "block_sizes": [
49
- 256,
50
- 32
51
- ],
52
- "loop_orders": [
53
- [
54
- 0,
55
- 1
56
- ]
57
- ],
58
- "flatten_loops": [
59
- true
60
- ],
61
- "l2_groupings": [
62
- 1
63
- ],
64
- "range_unroll_factors": [
65
- 0
66
- ],
67
- "range_warp_specializes": [],
68
- "range_num_stages": [
69
- 0
70
- ],
71
- "range_multi_buffers": [
72
- null
73
- ],
74
- "range_flattens": [
75
- null
76
- ],
77
- "load_eviction_policies": [
78
- "",
79
- "",
80
- ""
81
- ],
82
- "num_warps": 8,
83
- "num_stages": 1,
84
- "indexing": [
85
- "pointer",
86
- "pointer",
87
- "pointer",
88
- "pointer"
89
- ],
90
- "pid_type": "flat"
91
- },
92
- "default": {
93
- "block_sizes": [
94
- 1,
95
- 512
96
- ],
97
- "loop_orders": [
98
- [
1
+[
2
+ {
3
+ "key": {
4
+ "intermediate": 2048,
5
+ "numtokens": 256
6
+ },
7
+ "config": {
8
+ "block_sizes": [
9
+ 64,
10
+ 32
11
+ ],
12
+ "loop_orders": [
13
+ [
14
+ 0,
15
+ 1
16
+ ]
17
+ ],
18
+ "flatten_loops": [
19
+ true
20
+ ],
21
+ "l2_groupings": [
22
+ 1
23
+ ],
24
+ "range_unroll_factors": [
25
+ 0
26
+ ],
27
+ "range_warp_specializes": [],
28
+ "range_num_stages": [
29
+ 0
30
+ ],
31
+ "range_multi_buffers": [
32
+ null
33
+ ],
34
+ "range_flattens": [
35
+ null
36
+ ],
37
+ "load_eviction_policies": [
38
+ "",
39
+ "",
40
+ ""
41
+ ],
42
+ "num_warps": 8,
43
+ "num_stages": 1,
44
+ "indexing": [
45
+ "pointer",
46
+ "pointer",
47
+ "pointer",
48
+ "pointer"
49
+ ],
50
+ "pid_type": "flat"
51
+ }
52
+ },
53
+ {
54
+ "key": {
55
+ "intermediate": 4096,
56
+ "numtokens": 256
57
+ },
58
+ "config": {
59
+ "block_sizes": [
60
+ 256,
61
+ 32
62
+ ],
63
+ "loop_orders": [
64
+ [
65
+ 0,
66
+ 1
67
+ ]
68
+ ],
69
+ "flatten_loops": [
70
+ true
71
+ ],
72
+ "l2_groupings": [
73
+ 1
74
+ ],
75
+ "range_unroll_factors": [
76
+ 0
77
+ ],
78
+ "range_warp_specializes": [],
79
+ "range_num_stages": [
80
+ 0
81
+ ],
82
+ "range_multi_buffers": [
83
+ null
84
+ ],
85
+ "range_flattens": [
86
+ null
87
+ ],
88
+ "load_eviction_policies": [
89
+ "",
90
+ "",
91
+ ""
92
+ ],
93
+ "num_warps": 8,
94
+ "num_stages": 1,
95
+ "indexing": [
96
+ "pointer",
97
+ "pointer",
98
+ "pointer",
99
+ "pointer"
100
+ ],
101
+ "pid_type": "flat"
102
+ }
103
+ },
104
+ {
105
+ "key": {},
106
+ "config": {
107
+ "block_sizes": [
108
+ 1,
109
+ 512
110
+ ],
111
+ "loop_orders": [
112
+ [
113
+ 1,
114
+ 0
115
+ ]
116
+ ],
117
+ "flatten_loops": [
118
+ false
119
+ ],
120
+ "l2_groupings": [
121
+ 4
122
+ ],
123
+ "range_unroll_factors": [
124
+ 0
125
+ ],
126
+ "range_warp_specializes": [],
127
+ "range_num_stages": [
128
+ 0
129
+ ],
130
+ "range_multi_buffers": [
131
+ null
132
+ ],
133
+ "range_flattens": [
134
+ null
135
+ ],
136
+ "load_eviction_policies": [
137
+ "",
138
+ "first",
139
+ ""
140
+ ],
141
+ "num_warps": 8,
142
+ "num_stages": 2,
143
+ "indexing": [
144
+ "tensor_descriptor",
145
+ "tensor_descriptor",
146
+ "tensor_descriptor",
147
+ "pointer"
148
+ ],
149
+ "pid_type": "flat"
150
+ }
151
+ },
152
+ {
153
+ "key": {
154
+ "intermediate": 8192,
155
+ "numtokens": 256
156
+ },
157
+ "config": {
158
+ "block_sizes": [
159
+ 256,
160
+ 64
161
+ ],
162
+ "loop_orders": [
163
+ [
164
+ 0,
165
+ 1
166
+ ]
167
+ ],
168
+ "flatten_loops": [
169
+ true
170
+ ],
171
+ "l2_groupings": [
172
+ 1
173
+ ],
174
+ "range_unroll_factors": [
175
+ 0
176
+ ],
177
+ "range_warp_specializes": [],
178
+ "range_num_stages": [
179
+ 0
180
+ ],
181
+ "range_multi_buffers": [
182
+ null
183
+ ],
184
+ "range_flattens": [
185
+ null
186
+ ],
187
+ "load_eviction_policies": [
188
+ "",
189
+ "",
190
+ ""
191
+ ],
192
+ "num_warps": 8,
193
+ "num_stages": 1,
194
+ "indexing": [
195
+ "pointer",
196
+ "pointer",
197
+ "pointer",
198
+ "pointer"
199
+ ],
200
+ "pid_type": "flat"
201
+ }
202
+ },
203
+ {
204
+ "key": {
205
+ "intermediate": 14336,
206
+ "numtokens": 256
207
+ },
208
+ "config": {
209
+ "block_sizes": [
210
+ 8,
211
+ 4096
212
+ ],
213
+ "loop_orders": [
214
+ [
215
+ 0,
216
+ 1
217
+ ]
218
+ ],
219
+ "flatten_loops": [
220
+ true
221
+ ],
222
+ "l2_groupings": [
223
+ 1
224
+ ],
225
+ "range_unroll_factors": [
226
+ 0
227
+ ],
228
+ "range_warp_specializes": [],
229
+ "range_num_stages": [
230
+ 0
231
+ ],
232
+ "range_multi_buffers": [
233
+ null
234
+ ],
235
+ "range_flattens": [
236
+ null
237
+ ],
238
+ "load_eviction_policies": [
239
+ "",
240
+ "",
241
+ ""
242
+ ],
243
+ "num_warps": 8,
244
+ "num_stages": 1,
245
+ "indexing": [
246
+ "pointer",
247
+ "pointer",
248
+ "pointer",
249
+ "pointer"
250
+ ],
251
+ "pid_type": "flat"
252
+ }
253
+ },
254
+ {
255
+ "key": {
256
+ "intermediate": 11008,
257
+ "numtokens": 256
258
+ },
259
+ "config": {
260
+ "block_sizes": [
261
+ 64,
262
+ 32
263
+ ],
264
+ "loop_orders": [
265
+ [
266
+ 0,
267
+ 1
268
+ ]
269
+ ],
270
+ "flatten_loops": [
271
+ true
272
+ ],
273
+ "l2_groupings": [
274
+ 1
275
+ ],
276
+ "range_unroll_factors": [
277
+ 0
278
+ ],
279
+ "range_warp_specializes": [],
280
+ "range_num_stages": [
281
+ 0
282
+ ],
283
+ "range_multi_buffers": [
284
+ null
285
+ ],
286
+ "range_flattens": [
287
+ null
288
+ ],
289
+ "load_eviction_policies": [
290
+ "",
291
+ "",
292
+ ""
293
+ ],
294
+ "num_warps": 2,
295
+ "num_stages": 1,
296
+ "indexing": [
297
+ "pointer",
298
+ "pointer",
299
+ "pointer",
300
+ "pointer"
301
+ ],
302
+ "pid_type": "flat"
303
+ }
304
+ },
305
+ {
306
+ "key": {
307
+ "intermediate": 7688,
308
+ "numtokens": 256
309
+ },
310
+ "config": {
311
+ "block_sizes": [
312
+ 32,
313
+ 512
314
+ ],
315
+ "loop_orders": [
316
+ [
317
+ 0,
318
+ 1
319
+ ]
320
+ ],
321
+ "flatten_loops": [
322
+ true
323
+ ],
324
+ "l2_groupings": [
325
+ 1
326
+ ],
327
+ "range_unroll_factors": [
328
+ 0
329
+ ],
330
+ "range_warp_specializes": [],
331
+ "range_num_stages": [
332
+ 0
333
+ ],
334
+ "range_multi_buffers": [
335
+ null
336
+ ],
337
+ "range_flattens": [
338
+ null
339
+ ],
340
+ "load_eviction_policies": [
341
+ "",
342
+ "",
343
+ ""
344
+ ],
345
+ "num_warps": 8,
346
+ "num_stages": 1,
347
+ "indexing": [
348
+ "pointer",
349
+ "pointer",
350
+ "pointer",
351
+ "pointer"
352
+ ],
353
+ "pid_type": "flat"
354
+ }
355
+ },
356
+ {
357
+ "key": {
358
+ "intermediate": 2880,
359
+ "numtokens": 256
360
+ },
361
+ "config": {
362
+ "block_sizes": [
363
+ 32,
364
+ 64
365
+ ],
366
+ "loop_orders": [
367
+ [
368
+ 0,
369
+ 1
370
+ ]
371
+ ],
372
+ "flatten_loops": [
373
+ true
374
+ ],
375
+ "l2_groupings": [
376
+ 2
377
+ ],
378
+ "range_unroll_factors": [
379
+ 0
380
+ ],
381
+ "range_warp_specializes": [],
382
+ "range_num_stages": [
383
+ 0
384
+ ],
385
+ "range_multi_buffers": [
386
+ null
387
+ ],
388
+ "range_flattens": [
389
+ null
390
+ ],
391
+ "load_eviction_policies": [
392
+ "",
393
+ "",
394
+ ""
395
+ ],
396
+ "num_warps": 8,
397
+ "num_stages": 1,
398
+ "indexing": [
399
+ "pointer",
400
+ "pointer",
401
+ "pointer",
402
+ "pointer"
403
+ ],
404
+ "pid_type": "flat"
405
+ }
406
+ },
407
+ {
408
+ "key": {
409
+ "intermediate": 2048,
410
+ "numtokens": 1
411
+ },
412
+ "config": {
413
+ "block_sizes": [
414
+ 1,
415
+ 256
416
+ ],
417
+ "loop_orders": [
418
+ [
419
+ 0,
420
+ 1
421
+ ]
422
+ ],
423
+ "flatten_loops": [
424
+ true
425
+ ],
426
+ "l2_groupings": [
427
+ 1
428
+ ],
429
+ "range_unroll_factors": [
430
+ 0
431
+ ],
432
+ "range_warp_specializes": [],
433
+ "range_num_stages": [
434
+ 0
435
+ ],
436
+ "range_multi_buffers": [
437
+ null
438
+ ],
439
+ "range_flattens": [
440
+ null
441
+ ],
442
+ "load_eviction_policies": [
443
+ "",
444
+ "",
445
+ ""
446
+ ],
447
+ "num_warps": 2,
448
+ "num_stages": 1,
449
+ "indexing": [
450
+ "pointer",
451
+ "pointer",
452
+ "pointer",
453
+ "pointer"
454
+ ],
455
+ "pid_type": "flat"
456
+ }
457
+ },
458
+ {
459
+ "key": {
460
+ "intermediate": 2880,
461
+ "numtokens": 1
462
+ },
463
+ "config": {
464
+ "block_sizes": [
465
+ 1,
466
+ 128
467
+ ],
468
+ "loop_orders": [
469
+ [
470
+ 0,
471
+ 1
472
+ ]
473
+ ],
474
+ "flatten_loops": [
475
+ true
476
+ ],
477
+ "l2_groupings": [
478
+ 1
479
+ ],
480
+ "range_unroll_factors": [
481
+ 0
482
+ ],
483
+ "range_warp_specializes": [],
484
+ "range_num_stages": [
485
+ 0
486
+ ],
487
+ "range_multi_buffers": [
488
+ null
489
+ ],
490
+ "range_flattens": [
491
+ null
492
+ ],
493
+ "load_eviction_policies": [
494
+ "",
495
+ "",
496
+ ""
497
+ ],
498
+ "num_warps": 4,
499
+ "num_stages": 1,
500
+ "indexing": [
501
+ "pointer",
502
+ "pointer",
503
+ "pointer",
504
+ "pointer"
505
+ ],
506
+ "pid_type": "flat"
507
+ }
508
+ },
509
+ {
510
+ "key": {
511
+ "intermediate": 4096,
512
+ "numtokens": 1
513
+ },
514
+ "config": {
515
+ "block_sizes": [
516
+ 1,
517
+ 256
518
+ ],
519
+ "loop_orders": [
520
+ [
521
+ 0,
522
+ 1
523
+ ]
524
+ ],
525
+ "flatten_loops": [
526
+ true
527
+ ],
528
+ "l2_groupings": [
529
+ 1
530
+ ],
531
+ "range_unroll_factors": [
532
+ 0
533
+ ],
534
+ "range_warp_specializes": [],
535
+ "range_num_stages": [
536
+ 0
537
+ ],
538
+ "range_multi_buffers": [
539
+ null
540
+ ],
541
+ "range_flattens": [
542
+ null
543
+ ],
544
+ "load_eviction_policies": [
545
+ "",
546
+ "",
547
+ ""
548
+ ],
549
+ "num_warps": 2,
550
+ "num_stages": 1,
551
+ "indexing": [
552
+ "pointer",
553
+ "pointer",
554
+ "pointer",
555
+ "pointer"
556
+ ],
557
+ "pid_type": "flat"
558
+ }
559
+ },
560
+ {
561
+ "key": {
562
+ "intermediate": 8192,
563
+ "numtokens": 1
564
+ },
565
+ "config": {
566
+ "block_sizes": [
567
+ 1,
568
+ 256
569
+ ],
570
+ "loop_orders": [
571
+ [
572
+ 0,
573
+ 1
574
+ ]
575
+ ],
576
+ "flatten_loops": [
577
+ true
578
+ ],
579
+ "l2_groupings": [
580
+ 1
581
+ ],
582
+ "range_unroll_factors": [
583
+ 0
584
+ ],
585
+ "range_warp_specializes": [],
586
+ "range_num_stages": [
587
+ 0
588
+ ],
589
+ "range_multi_buffers": [
590
+ null
591
+ ],
592
+ "range_flattens": [
593
+ null
594
+ ],
595
+ "load_eviction_policies": [
596
+ "",
597
+ "",
598
+ ""
599
+ ],
600
+ "num_warps": 2,
601
+ "num_stages": 1,
602
+ "indexing": [
603
+ "pointer",
604
+ "pointer",
605
+ "pointer",
606
+ "pointer"
607
+ ],
608
+ "pid_type": "flat"
609
+ }
610
+ },
611
+ {
612
+ "key": {
613
+ "intermediate": 11008,
614
+ "numtokens": 1
615
+ },
616
+ "config": {
617
+ "block_sizes": [
618
+ 1,
619
+ 256
620
+ ],
621
+ "loop_orders": [
622
+ [
623
+ 0,
624
+ 1
625
+ ]
626
+ ],
627
+ "flatten_loops": [
628
+ true
629
+ ],
630
+ "l2_groupings": [
631
+ 1
632
+ ],
633
+ "range_unroll_factors": [
634
+ 0
635
+ ],
636
+ "range_warp_specializes": [],
637
+ "range_num_stages": [
638
+ 0
639
+ ],
640
+ "range_multi_buffers": [
641
+ null
642
+ ],
643
+ "range_flattens": [
644
+ null
645
+ ],
646
+ "load_eviction_policies": [
647
+ "",
648
+ "",
649
+ ""
650
+ ],
651
+ "num_warps": 2,
652
+ "num_stages": 1,
653
+ "indexing": [
654
+ "pointer",
655
+ "pointer",
656
+ "pointer",
657
+ "pointer"
658
+ ],
659
+ "pid_type": "flat"
660
+ }
661
+ },
662
+ {
663
+ "key": {
664
+ "intermediate": 14336,
665
+ "numtokens": 1
666
+ },
667
+ "config": {
668
+ "block_sizes": [
669
+ 1,
670
+ 256
671
+ ],
672
+ "loop_orders": [
673
+ [
674
+ 0,
675
+ 1
676
+ ]
677
+ ],
678
+ "flatten_loops": [
679
+ true
680
+ ],
681
+ "l2_groupings": [
682
+ 1
683
+ ],
684
+ "range_unroll_factors": [
685
+ 0
686
+ ],
687
+ "range_warp_specializes": [],
688
+ "range_num_stages": [
689
+ 0
690
+ ],
691
+ "range_multi_buffers": [
692
+ null
693
+ ],
694
+ "range_flattens": [
695
+ null
696
+ ],
697
+ "load_eviction_policies": [
698
+ "",
699
+ "",
700
+ ""
701
+ ],
702
+ "num_warps": 2,
703
+ "num_stages": 1,
704
+ "indexing": [
705
+ "pointer",
706
+ "pointer",
707
+ "pointer",
708
+ "pointer"
709
+ ],
710
+ "pid_type": "flat"
711
+ }
712
+ },
713
+ {
714
+ "key": {
715
+ "intermediate": 2048,
716
+ "numtokens": 2
717
+ },
718
+ "config": {
719
+ "block_sizes": [
720
+ 2,
721
+ 128
722
+ ],
723
+ "loop_orders": [
724
+ [
725
+ 0,
726
+ 1
727
+ ]
728
+ ],
729
+ "flatten_loops": [
730
+ true
731
+ ],
732
+ "l2_groupings": [
733
+ 1
734
+ ],
735
+ "range_unroll_factors": [
736
+ 0
737
+ ],
738
+ "range_warp_specializes": [],
739
+ "range_num_stages": [
740
+ 0
741
+ ],
742
+ "range_multi_buffers": [
743
+ null
744
+ ],
745
+ "range_flattens": [
746
+ null
747
+ ],
748
+ "load_eviction_policies": [
749
+ "",
750
+ "",
751
+ ""
752
+ ],
753
+ "num_warps": 2,
754
+ "num_stages": 1,
755
+ "indexing": [
756
+ "pointer",
757
+ "pointer",
758
+ "pointer",
759
+ "pointer"
760
+ ],
761
+ "pid_type": "flat"
762
+ }
763
+ },
764
+ {
765
+ "key": {
766
+ "intermediate": 2880,
767
+ "numtokens": 2
768
+ },
769
+ "config": {
770
+ "block_sizes": [
771
+ 2,
772
+ 256
773
+ ],
774
+ "loop_orders": [
775
+ [
776
+ 0,
777
+ 1
778
+ ]
779
+ ],
780
+ "flatten_loops": [
781
+ true
782
+ ],
783
+ "l2_groupings": [
784
+ 1
785
+ ],
786
+ "range_unroll_factors": [
787
+ 0
788
+ ],
789
+ "range_warp_specializes": [],
790
+ "range_num_stages": [
791
+ 0
792
+ ],
793
+ "range_multi_buffers": [
794
+ null
795
+ ],
796
+ "range_flattens": [
797
+ null
798
+ ],
799
+ "load_eviction_policies": [
800
+ "",
801
+ "",
802
+ ""
803
+ ],
804
+ "num_warps": 4,
805
+ "num_stages": 1,
806
+ "indexing": [
807
+ "pointer",
808
+ "pointer",
809
+ "pointer",
810
+ "pointer"
811
+ ],
812
+ "pid_type": "flat"
813
+ }
814
+ },
815
+ {
816
+ "key": {
817
+ "intermediate": 4096,
818
+ "numtokens": 2
819
+ },
820
+ "config": {
821
+ "block_sizes": [
822
+ 2,
823
+ 128
824
+ ],
825
+ "loop_orders": [
826
+ [
827
+ 0,
828
+ 1
829
+ ]
830
+ ],
831
+ "flatten_loops": [
832
+ true
833
+ ],
834
+ "l2_groupings": [
835
+ 1
836
+ ],
837
+ "range_unroll_factors": [
838
+ 0
839
+ ],
840
+ "range_warp_specializes": [],
841
+ "range_num_stages": [
842
+ 0
843
+ ],
844
+ "range_multi_buffers": [
845
+ null
846
+ ],
847
+ "range_flattens": [
848
+ null
849
+ ],
850
+ "load_eviction_policies": [
851
+ "",
852
+ "",
853
+ ""
854
+ ],
855
+ "num_warps": 2,
856
+ "num_stages": 1,
857
+ "indexing": [
858
+ "pointer",
859
+ "pointer",
860
+ "pointer",
861
+ "pointer"
862
+ ],
863
+ "pid_type": "flat"
864
+ }
865
+ },
866
+ {
867
+ "key": {
868
+ "intermediate": 8192,
869
+ "numtokens": 2
870
+ },
871
+ "config": {
872
+ "block_sizes": [
873
+ 2,
874
+ 128
875
+ ],
876
+ "loop_orders": [
877
+ [
878
+ 0,
879
+ 1
880
+ ]
881
+ ],
882
+ "flatten_loops": [
883
+ true
884
+ ],
885
+ "l2_groupings": [
886
+ 1
887
+ ],
888
+ "range_unroll_factors": [
889
+ 0
890
+ ],
891
+ "range_warp_specializes": [],
892
+ "range_num_stages": [
893
+ 0
894
+ ],
895
+ "range_multi_buffers": [
896
+ null
897
+ ],
898
+ "range_flattens": [
899
+ null
900
+ ],
901
+ "load_eviction_policies": [
902
+ "",
903
+ "",
904
+ ""
905
+ ],
906
+ "num_warps": 2,
907
+ "num_stages": 1,
908
+ "indexing": [
909
+ "pointer",
910
+ "pointer",
911
+ "pointer",
912
+ "pointer"
913
+ ],
914
+ "pid_type": "flat"
915
+ }
916
+ },
917
+ {
918
+ "key": {
919
+ "intermediate": 11008,
920
+ "numtokens": 2
921
+ },
922
+ "config": {
923
+ "block_sizes": [
924
+ 1,
925
+ 16384
926
+ ],
927
+ "loop_orders": [
928
+ [
929
+ 1,
930
+ 0
931
+ ]
932
+ ],
933
+ "flatten_loops": [
934
+ true
935
+ ],
936
+ "l2_groupings": [
937
+ 16
938
+ ],
939
+ "range_unroll_factors": [
940
+ 0
941
+ ],
942
+ "range_warp_specializes": [],
943
+ "range_num_stages": [
944
+ 0
945
+ ],
946
+ "range_multi_buffers": [
947
+ null
948
+ ],
949
+ "range_flattens": [
950
+ null
951
+ ],
952
+ "load_eviction_policies": [
953
+ "last",
954
+ "first",
955
+ "last"
956
+ ],
957
+ "num_warps": 32,
958
+ "num_stages": 3,
959
+ "indexing": [
960
+ "tensor_descriptor",
961
+ "pointer",
962
+ "pointer",
963
+ "tensor_descriptor"
964
+ ],
965
+ "pid_type": "xyz"
966
+ }
967
+ },
968
+ {
969
+ "key": {
970
+ "intermediate": 14336,
971
+ "numtokens": 2
972
+ },
973
+ "config": {
974
+ "block_sizes": [
975
+ 2,
976
+ 128
977
+ ],
978
+ "loop_orders": [
979
+ [
980
+ 0,
981
+ 1
982
+ ]
983
+ ],
984
+ "flatten_loops": [
985
+ true
986
+ ],
987
+ "l2_groupings": [
988
+ 1
989
+ ],
990
+ "range_unroll_factors": [
991
+ 0
992
+ ],
993
+ "range_warp_specializes": [],
994
+ "range_num_stages": [
995
+ 0
996
+ ],
997
+ "range_multi_buffers": [
998
+ null
999
+ ],
1000
+ "range_flattens": [
1001
+ null
1002
+ ],
1003
+ "load_eviction_policies": [
1004
+ "",
1005
+ "",
1006
+ ""
1007
+ ],
1008
+ "num_warps": 2,
1009
+ "num_stages": 1,
1010
+ "indexing": [
1011
+ "pointer",
1012
+ "pointer",
1013
+ "pointer",
1014
+ "pointer"
1015
+ ],
1016
+ "pid_type": "flat"
1017
+ }
1018
+ },
1019
+ {
1020
+ "key": {
1021
+ "intermediate": 2048,
1022
+ "numtokens": 4
1023
+ },
1024
+ "config": {
1025
+ "block_sizes": [
1026
+ 4,
1027
+ 64
1028
+ ],
1029
+ "loop_orders": [
1030
+ [
1031
+ 0,
1032
+ 1
1033
+ ]
1034
+ ],
1035
+ "flatten_loops": [
1036
+ true
1037
+ ],
1038
+ "l2_groupings": [
1039
+ 1
1040
+ ],
1041
+ "range_unroll_factors": [
1042
+ 0
1043
+ ],
1044
+ "range_warp_specializes": [],
1045
+ "range_num_stages": [
1046
+ 0
1047
+ ],
1048
+ "range_multi_buffers": [
1049
+ null
1050
+ ],
1051
+ "range_flattens": [
1052
+ null
1053
+ ],
1054
+ "load_eviction_policies": [
1055
+ "",
1056
+ "",
1057
+ ""
1058
+ ],
1059
+ "num_warps": 2,
1060
+ "num_stages": 1,
1061
+ "indexing": [
1062
+ "pointer",
1063
+ "pointer",
1064
+ "pointer",
1065
+ "pointer"
1066
+ ],
1067
+ "pid_type": "flat"
1068
+ }
1069
+ },
1070
+ {
1071
+ "key": {
1072
+ "intermediate": 2880,
1073
+ "numtokens": 4
1074
+ },
1075
+ "config": {
1076
+ "block_sizes": [
1077
+ 4,
1078
+ 64
1079
+ ],
1080
+ "loop_orders": [
1081
+ [
1082
+ 0,
1083
+ 1
1084
+ ]
1085
+ ],
1086
+ "flatten_loops": [
1087
+ true
1088
+ ],
1089
+ "l2_groupings": [
1090
+ 64
1091
+ ],
1092
+ "range_unroll_factors": [
1093
+ 0
1094
+ ],
1095
+ "range_warp_specializes": [],
1096
+ "range_num_stages": [
1097
+ 0
1098
+ ],
1099
+ "range_multi_buffers": [
1100
+ null
1101
+ ],
1102
+ "range_flattens": [
1103
+ null
1104
+ ],
1105
+ "load_eviction_policies": [
1106
+ "",
1107
+ "last",
1108
+ "first"
1109
+ ],
1110
+ "num_warps": 8,
1111
+ "num_stages": 7,
1112
+ "indexing": [
1113
+ "pointer",
1114
+ "tensor_descriptor",
1115
+ "tensor_descriptor",
1116
+ "pointer"
1117
+ ],
1118
+ "pid_type": "xyz"
1119
+ }
1120
+ },
1121
+ {
1122
+ "key": {
1123
+ "intermediate": 4096,
1124
+ "numtokens": 4
1125
+ },
1126
+ "config": {
1127
+ "block_sizes": [
1128
+ 4,
1129
+ 64
1130
+ ],
1131
+ "loop_orders": [
1132
+ [
1133
+ 0,
1134
+ 1
1135
+ ]
1136
+ ],
1137
+ "flatten_loops": [
1138
+ true
1139
+ ],
1140
+ "l2_groupings": [
1141
+ 1
1142
+ ],
1143
+ "range_unroll_factors": [
1144
+ 0
1145
+ ],
1146
+ "range_warp_specializes": [],
1147
+ "range_num_stages": [
1148
+ 0
1149
+ ],
1150
+ "range_multi_buffers": [
1151
+ null
1152
+ ],
1153
+ "range_flattens": [
1154
+ null
1155
+ ],
1156
+ "load_eviction_policies": [
1157
+ "",
1158
+ "",
1159
+ ""
1160
+ ],
1161
+ "num_warps": 2,
1162
+ "num_stages": 1,
1163
+ "indexing": [
1164
+ "pointer",
1165
+ "pointer",
1166
+ "pointer",
1167
+ "pointer"
1168
+ ],
1169
+ "pid_type": "flat"
1170
+ }
1171
+ },
1172
+ {
1173
+ "key": {
1174
+ "intermediate": 8192,
1175
+ "numtokens": 4
1176
+ },
1177
+ "config": {
1178
+ "block_sizes": [
1179
+ 1,
1180
+ 2048
1181
+ ],
1182
+ "loop_orders": [
1183
+ [
1184
+ 0,
1185
+ 1
1186
+ ]
1187
+ ],
1188
+ "flatten_loops": [
1189
+ false
1190
+ ],
1191
+ "l2_groupings": [
1192
+ 1
1193
+ ],
1194
+ "range_unroll_factors": [
1195
+ 0
1196
+ ],
1197
+ "range_warp_specializes": [],
1198
+ "range_num_stages": [
1199
+ 0
1200
+ ],
1201
+ "range_multi_buffers": [
1202
+ null
1203
+ ],
1204
+ "range_flattens": [
1205
+ null
1206
+ ],
1207
+ "load_eviction_policies": [
1208
+ "",
1209
+ "",
1210
+ ""
1211
+ ],
1212
+ "num_warps": 8,
1213
+ "num_stages": 8,
1214
+ "indexing": [
1215
+ "pointer",
1216
+ "tensor_descriptor",
1217
+ "pointer",
1218
+ "pointer"
1219
+ ],
1220
+ "pid_type": "flat"
1221
+ }
1222
+ },
1223
+ {
1224
+ "key": {
1225
+ "intermediate": 11008,
1226
+ "numtokens": 4
1227
+ },
1228
+ "config": {
1229
+ "block_sizes": [
1230
+ 4,
1231
+ 2048
1232
+ ],
1233
+ "loop_orders": [
1234
+ [
1235
+ 1,
1236
+ 0
1237
+ ]
1238
+ ],
1239
+ "flatten_loops": [
1240
+ true
1241
+ ],
1242
+ "l2_groupings": [
1243
+ 4
1244
+ ],
1245
+ "range_unroll_factors": [
1246
+ 0
1247
+ ],
1248
+ "range_warp_specializes": [],
1249
+ "range_num_stages": [
1250
+ 0
1251
+ ],
1252
+ "range_multi_buffers": [
1253
+ null
1254
+ ],
1255
+ "range_flattens": [
1256
+ null
1257
+ ],
1258
+ "load_eviction_policies": [
1259
+ "first",
1260
+ "last",
1261
+ "last"
1262
+ ],
1263
+ "num_warps": 8,
1264
+ "num_stages": 6,
1265
+ "indexing": [
1266
+ "pointer",
1267
+ "tensor_descriptor",
1268
+ "tensor_descriptor",
1269
+ "tensor_descriptor"
1270
+ ],
1271
+ "pid_type": "xyz"
1272
+ }
1273
+ },
1274
+ {
1275
+ "key": {
1276
+ "intermediate": 14336,
1277
+ "numtokens": 4
1278
+ },
1279
+ "config": {
1280
+ "block_sizes": [
1281
+ 4,
1282
+ 256
1283
+ ],
1284
+ "loop_orders": [
1285
+ [
1286
+ 0,
1287
+ 1
1288
+ ]
1289
+ ],
1290
+ "flatten_loops": [
1291
+ true
1292
+ ],
1293
+ "l2_groupings": [
1294
+ 64
1295
+ ],
1296
+ "range_unroll_factors": [
1297
+ 0
1298
+ ],
1299
+ "range_warp_specializes": [],
1300
+ "range_num_stages": [
1301
+ 0
1302
+ ],
1303
+ "range_multi_buffers": [
1304
+ null
1305
+ ],
1306
+ "range_flattens": [
1307
+ null
1308
+ ],
1309
+ "load_eviction_policies": [
1310
+ "",
1311
+ "",
1312
+ ""
1313
+ ],
1314
+ "num_warps": 2,
1315
+ "num_stages": 2,
1316
+ "indexing": [
1317
+ "pointer",
1318
+ "pointer",
1319
+ "pointer",
1320
+ "pointer"
1321
+ ],
1322
+ "pid_type": "xyz"
1323
+ }
1324
+ },
1325
+ {
1326
+ "key": {
1327
+ "intermediate": 2048,
1328
+ "numtokens": 8
1329
+ },
1330
+ "config": {
1331
+ "block_sizes": [
1332
+ 8,
1333
+ 32
1334
+ ],
1335
+ "loop_orders": [
1336
+ [
1337
+ 0,
1338
+ 1
1339
+ ]
1340
+ ],
1341
+ "flatten_loops": [
1342
+ true
1343
+ ],
1344
+ "l2_groupings": [
1345
+ 1
1346
+ ],
1347
+ "range_unroll_factors": [
1348
+ 0
1349
+ ],
1350
+ "range_warp_specializes": [],
1351
+ "range_num_stages": [
1352
+ 0
1353
+ ],
1354
+ "range_multi_buffers": [
1355
+ null
1356
+ ],
1357
+ "range_flattens": [
1358
+ null
1359
+ ],
1360
+ "load_eviction_policies": [
1361
+ "",
1362
+ "",
1363
+ ""
1364
+ ],
1365
+ "num_warps": 2,
1366
+ "num_stages": 1,
1367
+ "indexing": [
1368
+ "pointer",
1369
+ "pointer",
1370
+ "pointer",
1371
+ "pointer"
1372
+ ],
1373
+ "pid_type": "flat"
1374
+ }
1375
+ },
1376
+ {
1377
+ "key": {
1378
+ "intermediate": 2880,
1379
+ "numtokens": 8
1380
+ },
1381
+ "config": {
1382
+ "block_sizes": [
1383
+ 4,
1384
+ 2048
1385
+ ],
1386
+ "loop_orders": [
1387
+ [
1388
+ 0,
1389
+ 1
1390
+ ]
1391
+ ],
1392
+ "flatten_loops": [
1393
+ true
1394
+ ],
1395
+ "l2_groupings": [
1396
+ 4
1397
+ ],
1398
+ "range_unroll_factors": [
1399
+ 0
1400
+ ],
1401
+ "range_warp_specializes": [],
1402
+ "range_num_stages": [
1403
+ 0
1404
+ ],
1405
+ "range_multi_buffers": [
1406
+ null
1407
+ ],
1408
+ "range_flattens": [
1409
+ null
1410
+ ],
1411
+ "load_eviction_policies": [
1412
+ "last",
1413
+ "last",
1414
+ ""
1415
+ ],
1416
+ "num_warps": 16,
1417
+ "num_stages": 5,
1418
+ "indexing": [
1419
+ "pointer",
1420
+ "tensor_descriptor",
1421
+ "tensor_descriptor",
1422
+ "pointer"
1423
+ ],
1424
+ "pid_type": "xyz"
1425
+ }
1426
+ },
1427
+ {
1428
+ "key": {
1429
+ "intermediate": 4096,
1430
+ "numtokens": 8
1431
+ },
1432
+ "config": {
1433
+ "block_sizes": [
1434
+ 8,
1435
+ 32
1436
+ ],
1437
+ "loop_orders": [
1438
+ [
1439
+ 0,
1440
+ 1
1441
+ ]
1442
+ ],
1443
+ "flatten_loops": [
1444
+ true
1445
+ ],
1446
+ "l2_groupings": [
1447
+ 1
1448
+ ],
1449
+ "range_unroll_factors": [
1450
+ 0
1451
+ ],
1452
+ "range_warp_specializes": [],
1453
+ "range_num_stages": [
1454
+ 0
1455
+ ],
1456
+ "range_multi_buffers": [
1457
+ null
1458
+ ],
1459
+ "range_flattens": [
1460
+ null
1461
+ ],
1462
+ "load_eviction_policies": [
1463
+ "",
1464
+ "",
1465
+ ""
1466
+ ],
1467
+ "num_warps": 2,
1468
+ "num_stages": 1,
1469
+ "indexing": [
1470
+ "pointer",
1471
+ "pointer",
1472
+ "pointer",
1473
+ "pointer"
1474
+ ],
1475
+ "pid_type": "flat"
1476
+ }
1477
+ },
1478
+ {
1479
+ "key": {
1480
+ "intermediate": 8192,
1481
+ "numtokens": 8
1482
+ },
1483
+ "config": {
1484
+ "block_sizes": [
1485
+ 2,
1486
+ 1024
1487
+ ],
1488
+ "loop_orders": [
1489
+ [
1490
+ 0,
1491
+ 1
1492
+ ]
1493
+ ],
1494
+ "flatten_loops": [
1495
+ true
1496
+ ],
1497
+ "l2_groupings": [
1498
+ 16
1499
+ ],
1500
+ "range_unroll_factors": [
1501
+ 0
1502
+ ],
1503
+ "range_warp_specializes": [],
1504
+ "range_num_stages": [
1505
+ 0
1506
+ ],
1507
+ "range_multi_buffers": [
1508
+ null
1509
+ ],
1510
+ "range_flattens": [
1511
+ null
1512
+ ],
1513
+ "load_eviction_policies": [
1514
+ "first",
1515
+ "last",
1516
+ ""
1517
+ ],
1518
+ "num_warps": 1,
1519
+ "num_stages": 8,
1520
+ "indexing": [
1521
+ "tensor_descriptor",
1522
+ "pointer",
1523
+ "tensor_descriptor",
1524
+ "pointer"
1525
+ ],
1526
+ "pid_type": "flat"
1527
+ }
1528
+ },
1529
+ {
1530
+ "key": {
1531
+ "intermediate": 11008,
1532
+ "numtokens": 8
1533
+ },
1534
+ "config": {
1535
+ "block_sizes": [
1536
+ 1,
1537
+ 1024
1538
+ ],
1539
+ "loop_orders": [
1540
+ [
1541
+ 1,
1542
+ 0
1543
+ ]
1544
+ ],
1545
+ "flatten_loops": [
1546
+ true
1547
+ ],
1548
+ "l2_groupings": [
1549
+ 4
1550
+ ],
1551
+ "range_unroll_factors": [
1552
+ 0
1553
+ ],
1554
+ "range_warp_specializes": [],
1555
+ "range_num_stages": [
1556
+ 0
1557
+ ],
1558
+ "range_multi_buffers": [
1559
+ null
1560
+ ],
1561
+ "range_flattens": [
1562
+ null
1563
+ ],
1564
+ "load_eviction_policies": [
1565
+ "last",
1566
+ "",
1567
+ "first"
1568
+ ],
1569
+ "num_warps": 2,
1570
+ "num_stages": 5,
1571
+ "indexing": [
1572
+ "tensor_descriptor",
1573
+ "tensor_descriptor",
1574
+ "tensor_descriptor",
1575
+ "tensor_descriptor"
1576
+ ],
1577
+ "pid_type": "flat"
1578
+ }
1579
+ },
1580
+ {
1581
+ "key": {
1582
+ "intermediate": 14336,
1583
+ "numtokens": 8
1584
+ },
1585
+ "config": {
1586
+ "block_sizes": [
1587
+ 8,
1588
+ 128
1589
+ ],
1590
+ "loop_orders": [
1591
+ [
1592
+ 0,
1593
+ 1
1594
+ ]
1595
+ ],
1596
+ "flatten_loops": [
1597
+ true
1598
+ ],
1599
+ "l2_groupings": [
1600
+ 1
1601
+ ],
1602
+ "range_unroll_factors": [
1603
+ 0
1604
+ ],
1605
+ "range_warp_specializes": [],
1606
+ "range_num_stages": [
1607
+ 0
1608
+ ],
1609
+ "range_multi_buffers": [
1610
+ null
1611
+ ],
1612
+ "range_flattens": [
1613
+ null
1614
+ ],
1615
+ "load_eviction_policies": [
1616
+ "",
1617
+ "",
1618
+ ""
1619
+ ],
1620
+ "num_warps": 4,
1621
+ "num_stages": 1,
1622
+ "indexing": [
1623
+ "pointer",
1624
+ "pointer",
1625
+ "pointer",
1626
+ "pointer"
1627
+ ],
1628
+ "pid_type": "flat"
1629
+ }
1630
+ },
1631
+ {
1632
+ "key": {
1633
+ "intermediate": 2048,
1634
+ "numtokens": 16
1635
+ },
1636
+ "config": {
1637
+ "block_sizes": [
1638
+ 8,
1639
+ 512
1640
+ ],
1641
+ "loop_orders": [
1642
+ [
1643
+ 0,
1644
+ 1
1645
+ ]
1646
+ ],
1647
+ "flatten_loops": [
1648
+ true
1649
+ ],
1650
+ "l2_groupings": [
1651
+ 64
1652
+ ],
1653
+ "range_unroll_factors": [
1654
+ 0
1655
+ ],
1656
+ "range_warp_specializes": [],
1657
+ "range_num_stages": [
1658
+ 0
1659
+ ],
1660
+ "range_multi_buffers": [
1661
+ null
1662
+ ],
1663
+ "range_flattens": [
1664
+ null
1665
+ ],
1666
+ "load_eviction_policies": [
1667
+ "last",
1668
+ "last",
1669
+ "first"
1670
+ ],
1671
+ "num_warps": 16,
1672
+ "num_stages": 2,
1673
+ "indexing": [
1674
+ "pointer",
1675
+ "pointer",
1676
+ "tensor_descriptor",
1677
+ "pointer"
1678
+ ],
1679
+ "pid_type": "xyz"
1680
+ }
1681
+ },
1682
+ {
1683
+ "key": {
1684
+ "intermediate": 2880,
1685
+ "numtokens": 16
1686
+ },
1687
+ "config": {
1688
+ "block_sizes": [
1689
+ 2,
1690
+ 256
1691
+ ],
1692
+ "loop_orders": [
1693
+ [
1694
+ 0,
1695
+ 1
1696
+ ]
1697
+ ],
1698
+ "flatten_loops": [
1699
+ true
1700
+ ],
1701
+ "l2_groupings": [
1702
+ 1
1703
+ ],
1704
+ "range_unroll_factors": [
1705
+ 0
1706
+ ],
1707
+ "range_warp_specializes": [],
1708
+ "range_num_stages": [
1709
+ 0
1710
+ ],
1711
+ "range_multi_buffers": [
1712
+ null
1713
+ ],
1714
+ "range_flattens": [
1715
+ null
1716
+ ],
1717
+ "load_eviction_policies": [
1718
+ "",
1719
+ "",
1720
+ ""
1721
+ ],
1722
+ "num_warps": 4,
1723
+ "num_stages": 1,
1724
+ "indexing": [
1725
+ "pointer",
1726
+ "pointer",
1727
+ "pointer",
1728
+ "pointer"
1729
+ ],
1730
+ "pid_type": "flat"
1731
+ }
1732
+ },
1733
+ {
1734
+ "key": {
1735
+ "intermediate": 4096,
1736
+ "numtokens": 16
1737
+ },
1738
+ "config": {
1739
+ "block_sizes": [
1740
+ 16,
1741
+ 256
1742
+ ],
1743
+ "loop_orders": [
1744
+ [
1745
+ 0,
1746
+ 1
1747
+ ]
1748
+ ],
1749
+ "flatten_loops": [
1750
+ true
1751
+ ],
1752
+ "l2_groupings": [
1753
+ 16
1754
+ ],
1755
+ "range_unroll_factors": [
1756
+ 0
1757
+ ],
1758
+ "range_warp_specializes": [],
1759
+ "range_num_stages": [
1760
+ 0
1761
+ ],
1762
+ "range_multi_buffers": [
1763
+ null
1764
+ ],
1765
+ "range_flattens": [
1766
+ null
1767
+ ],
1768
+ "load_eviction_policies": [
1769
+ "last",
1770
+ "",
1771
+ "last"
1772
+ ],
1773
+ "num_warps": 32,
1774
+ "num_stages": 1,
1775
+ "indexing": [
1776
+ "pointer",
1777
+ "pointer",
1778
+ "pointer",
1779
+ "pointer"
1780
+ ],
1781
+ "pid_type": "flat"
1782
+ }
1783
+ },
1784
+ {
1785
+ "key": {
1786
+ "intermediate": 8192,
1787
+ "numtokens": 16
1788
+ },
1789
+ "config": {
1790
+ "block_sizes": [
1791
+ 16,
1792
+ 64
1793
+ ],
1794
+ "loop_orders": [
1795
+ [
1796
+ 0,
1797
+ 1
1798
+ ]
1799
+ ],
1800
+ "flatten_loops": [
1801
+ true
1802
+ ],
1803
+ "l2_groupings": [
1804
+ 1
1805
+ ],
1806
+ "range_unroll_factors": [
1807
+ 0
1808
+ ],
1809
+ "range_warp_specializes": [],
1810
+ "range_num_stages": [
1811
+ 0
1812
+ ],
1813
+ "range_multi_buffers": [
1814
+ null
1815
+ ],
1816
+ "range_flattens": [
1817
+ null
1818
+ ],
1819
+ "load_eviction_policies": [
1820
+ "",
1821
+ "",
1822
+ ""
1823
+ ],
1824
+ "num_warps": 4,
1825
+ "num_stages": 1,
1826
+ "indexing": [
1827
+ "pointer",
1828
+ "pointer",
1829
+ "pointer",
1830
+ "pointer"
1831
+ ],
1832
+ "pid_type": "flat"
1833
+ }
1834
+ },
1835
+ {
1836
+ "key": {
1837
+ "intermediate": 11008,
1838
+ "numtokens": 16
1839
+ },
1840
+ "config": {
1841
+ "block_sizes": [
1842
+ 1,
1843
+ 2048
1844
+ ],
1845
+ "loop_orders": [
1846
+ [
1847
+ 0,
1848
+ 1
1849
+ ]
1850
+ ],
1851
+ "flatten_loops": [
1852
+ true
1853
+ ],
1854
+ "l2_groupings": [
1855
+ 1
1856
+ ],
1857
+ "range_unroll_factors": [
1858
+ 0
1859
+ ],
1860
+ "range_warp_specializes": [],
1861
+ "range_num_stages": [
1862
+ 0
1863
+ ],
1864
+ "range_multi_buffers": [
1865
+ null
1866
+ ],
1867
+ "range_flattens": [
1868
+ null
1869
+ ],
1870
+ "load_eviction_policies": [
1871
+ "",
1872
+ "",
1873
+ ""
1874
+ ],
1875
+ "num_warps": 8,
1876
+ "num_stages": 1,
1877
+ "indexing": [
1878
+ "pointer",
1879
+ "pointer",
1880
+ "pointer",
1881
+ "pointer"
1882
+ ],
1883
+ "pid_type": "flat"
1884
+ }
1885
+ },
1886
+ {
1887
+ "key": {
1888
+ "intermediate": 14336,
1889
+ "numtokens": 16
1890
+ },
1891
+ "config": {
1892
+ "block_sizes": [
1893
+ 2,
1894
+ 256
1895
+ ],
1896
+ "loop_orders": [
1897
+ [
1898
+ 1,
1899
+ 0
1900
+ ]
1901
+ ],
1902
+ "flatten_loops": [
1903
+ true
1904
+ ],
1905
+ "l2_groupings": [
1906
+ 64
1907
+ ],
1908
+ "range_unroll_factors": [
1909
+ 0
1910
+ ],
1911
+ "range_warp_specializes": [],
1912
+ "range_num_stages": [
1913
+ 0
1914
+ ],
1915
+ "range_multi_buffers": [
1916
+ null
1917
+ ],
1918
+ "range_flattens": [
1919
+ null
1920
+ ],
1921
+ "load_eviction_policies": [
1922
+ "last",
1923
+ "last",
1924
+ "last"
1925
+ ],
1926
+ "num_warps": 16,
1927
+ "num_stages": 7,
1928
+ "indexing": [
1929
+ "tensor_descriptor",
1930
+ "pointer",
1931
+ "tensor_descriptor",
1932
+ "tensor_descriptor"
1933
+ ],
1934
+ "pid_type": "flat"
1935
+ }
1936
+ },
1937
+ {
1938
+ "key": {
1939
+ "intermediate": 2048,
1940
+ "numtokens": 24
1941
+ },
1942
+ "config": {
1943
+ "block_sizes": [
1944
+ 1,
1945
+ 1024
1946
+ ],
1947
+ "loop_orders": [
1948
+ [
1949
+ 0,
1950
+ 1
1951
+ ]
1952
+ ],
1953
+ "flatten_loops": [
1954
+ true
1955
+ ],
1956
+ "l2_groupings": [
1957
+ 64
1958
+ ],
1959
+ "range_unroll_factors": [
1960
+ 0
1961
+ ],
1962
+ "range_warp_specializes": [],
1963
+ "range_num_stages": [
1964
+ 0
1965
+ ],
1966
+ "range_multi_buffers": [
1967
+ null
1968
+ ],
1969
+ "range_flattens": [
1970
+ null
1971
+ ],
1972
+ "load_eviction_policies": [
1973
+ "",
1974
+ "",
1975
+ "first"
1976
+ ],
1977
+ "num_warps": 4,
1978
+ "num_stages": 8,
1979
+ "indexing": [
1980
+ "tensor_descriptor",
1981
+ "pointer",
1982
+ "pointer",
1983
+ "tensor_descriptor"
1984
+ ],
1985
+ "pid_type": "flat"
1986
+ }
1987
+ },
1988
+ {
1989
+ "key": {
1990
+ "intermediate": 2880,
1991
+ "numtokens": 24
1992
+ },
1993
+ "config": {
1994
+ "block_sizes": [
1995
+ 4,
1996
+ 1024
1997
+ ],
1998
+ "loop_orders": [
1999
+ [
2000
+ 0,
2001
+ 1
2002
+ ]
2003
+ ],
2004
+ "flatten_loops": [
2005
+ true
2006
+ ],
2007
+ "l2_groupings": [
2008
+ 16
2009
+ ],
2010
+ "range_unroll_factors": [
2011
+ 0
2012
+ ],
2013
+ "range_warp_specializes": [],
2014
+ "range_num_stages": [
2015
+ 0
2016
+ ],
2017
+ "range_multi_buffers": [
2018
+ null
2019
+ ],
2020
+ "range_flattens": [
2021
+ null
2022
+ ],
2023
+ "load_eviction_policies": [
2024
+ "first",
2025
+ "",
2026
+ "first"
2027
+ ],
2028
+ "num_warps": 16,
2029
+ "num_stages": 3,
2030
+ "indexing": [
2031
+ "tensor_descriptor",
2032
+ "pointer",
2033
+ "tensor_descriptor",
2034
+ "pointer"
2035
+ ],
2036
+ "pid_type": "flat"
2037
+ }
2038
+ },
2039
+ {
2040
+ "key": {
2041
+ "intermediate": 4096,
2042
+ "numtokens": 24
2043
+ },
2044
+ "config": {
2045
+ "block_sizes": [
2046
+ 16,
2047
+ 64
2048
+ ],
2049
+ "loop_orders": [
2050
+ [
2051
+ 0,
2052
+ 1
2053
+ ]
2054
+ ],
2055
+ "flatten_loops": [
2056
+ true
2057
+ ],
2058
+ "l2_groupings": [
2059
+ 1
2060
+ ],
2061
+ "range_unroll_factors": [
2062
+ 0
2063
+ ],
2064
+ "range_warp_specializes": [],
2065
+ "range_num_stages": [
2066
+ 0
2067
+ ],
2068
+ "range_multi_buffers": [
2069
+ null
2070
+ ],
2071
+ "range_flattens": [
2072
+ null
2073
+ ],
2074
+ "load_eviction_policies": [
2075
+ "",
2076
+ "",
2077
+ ""
2078
+ ],
2079
+ "num_warps": 4,
2080
+ "num_stages": 1,
2081
+ "indexing": [
2082
+ "pointer",
2083
+ "pointer",
2084
+ "pointer",
2085
+ "pointer"
2086
+ ],
2087
+ "pid_type": "flat"
2088
+ }
2089
+ },
2090
+ {
2091
+ "key": {
2092
+ "intermediate": 8192,
2093
+ "numtokens": 24
2094
+ },
2095
+ "config": {
2096
+ "block_sizes": [
2097
+ 1,
2098
+ 2048
2099
+ ],
2100
+ "loop_orders": [
2101
+ [
2102
+ 0,
2103
+ 1
2104
+ ]
2105
+ ],
2106
+ "flatten_loops": [
2107
+ true
2108
+ ],
2109
+ "l2_groupings": [
2110
+ 32
2111
+ ],
2112
+ "range_unroll_factors": [
2113
+ 0
2114
+ ],
2115
+ "range_warp_specializes": [],
2116
+ "range_num_stages": [
2117
+ 0
2118
+ ],
2119
+ "range_multi_buffers": [
2120
+ null
2121
+ ],
2122
+ "range_flattens": [
2123
+ null
2124
+ ],
2125
+ "load_eviction_policies": [
2126
+ "",
2127
+ "last",
2128
+ "last"
2129
+ ],
2130
+ "num_warps": 32,
2131
+ "num_stages": 5,
2132
+ "indexing": [
2133
+ "pointer",
2134
+ "pointer",
2135
+ "pointer",
2136
+ "tensor_descriptor"
2137
+ ],
2138
+ "pid_type": "flat"
2139
+ }
2140
+ },
2141
+ {
2142
+ "key": {
2143
+ "intermediate": 11008,
2144
+ "numtokens": 24
2145
+ },
2146
+ "config": {
2147
+ "block_sizes": [
2148
+ 1,
2149
+ 1024
2150
+ ],
2151
+ "loop_orders": [
2152
+ [
2153
+ 1,
2154
+ 0
2155
+ ]
2156
+ ],
2157
+ "flatten_loops": [
2158
+ false
2159
+ ],
2160
+ "l2_groupings": [
2161
+ 64
2162
+ ],
2163
+ "range_unroll_factors": [
2164
+ 0
2165
+ ],
2166
+ "range_warp_specializes": [],
2167
+ "range_num_stages": [
2168
+ 0
2169
+ ],
2170
+ "range_multi_buffers": [
2171
+ null
2172
+ ],
2173
+ "range_flattens": [
2174
+ null
2175
+ ],
2176
+ "load_eviction_policies": [
2177
+ "last",
2178
+ "",
2179
+ ""
2180
+ ],
2181
+ "num_warps": 2,
2182
+ "num_stages": 2,
2183
+ "indexing": [
2184
+ "pointer",
2185
+ "pointer",
2186
+ "pointer",
2187
+ "pointer"
2188
+ ],
2189
+ "pid_type": "flat"
2190
+ }
2191
+ },
2192
+ {
2193
+ "key": {
2194
+ "intermediate": 14336,
2195
+ "numtokens": 24
2196
+ },
2197
+ "config": {
2198
+ "block_sizes": [
2199
+ 8,
2200
+ 512
2201
+ ],
2202
+ "loop_orders": [
2203
+ [
2204
+ 0,
2205
+ 1
2206
+ ]
2207
+ ],
2208
+ "flatten_loops": [
2209
+ true
2210
+ ],
2211
+ "l2_groupings": [
2212
+ 4
2213
+ ],
2214
+ "range_unroll_factors": [
2215
+ 0
2216
+ ],
2217
+ "range_warp_specializes": [],
2218
+ "range_num_stages": [
2219
+ 0
2220
+ ],
2221
+ "range_multi_buffers": [
2222
+ null
2223
+ ],
2224
+ "range_flattens": [
2225
+ null
2226
+ ],
2227
+ "load_eviction_policies": [
2228
+ "last",
2229
+ "first",
2230
+ "first"
2231
+ ],
2232
+ "num_warps": 32,
2233
+ "num_stages": 3,
2234
+ "indexing": [
2235
+ "pointer",
2236
+ "tensor_descriptor",
2237
+ "pointer",
2238
+ "tensor_descriptor"
2239
+ ],
2240
+ "pid_type": "flat"
2241
+ }
2242
+ },
2243
+ {
2244
+ "key": {
2245
+ "intermediate": 2048,
2246
+ "numtokens": 32
2247
+ },
2248
+ "config": {
2249
+ "block_sizes": [
2250
+ 32,
2251
+ 16
2252
+ ],
2253
+ "loop_orders": [
2254
+ [
2255
+ 0,
2256
+ 1
2257
+ ]
2258
+ ],
2259
+ "flatten_loops": [
2260
+ true
2261
+ ],
2262
+ "l2_groupings": [
2263
+ 1
2264
+ ],
2265
+ "range_unroll_factors": [
2266
+ 0
2267
+ ],
2268
+ "range_warp_specializes": [],
2269
+ "range_num_stages": [
2270
+ 0
2271
+ ],
2272
+ "range_multi_buffers": [
2273
+ null
2274
+ ],
2275
+ "range_flattens": [
2276
+ null
2277
+ ],
2278
+ "load_eviction_policies": [
2279
+ "",
2280
+ "",
2281
+ ""
2282
+ ],
2283
+ "num_warps": 4,
2284
+ "num_stages": 1,
2285
+ "indexing": [
2286
+ "pointer",
2287
+ "pointer",
2288
+ "pointer",
2289
+ "pointer"
2290
+ ],
2291
+ "pid_type": "flat"
2292
+ }
2293
+ },
2294
+ {
2295
+ "key": {
2296
+ "intermediate": 2880,
2297
+ "numtokens": 32
2298
+ },
2299
+ "config": {
2300
+ "block_sizes": [
2301
+ 4,
2302
+ 256
2303
+ ],
2304
+ "loop_orders": [
2305
+ [
2306
+ 0,
2307
+ 1
2308
+ ]
2309
+ ],
2310
+ "flatten_loops": [
2311
+ true
2312
+ ],
2313
+ "l2_groupings": [
2314
+ 1
2315
+ ],
2316
+ "range_unroll_factors": [
2317
+ 0
2318
+ ],
2319
+ "range_warp_specializes": [],
2320
+ "range_num_stages": [
2321
+ 0
2322
+ ],
2323
+ "range_multi_buffers": [
2324
+ null
2325
+ ],
2326
+ "range_flattens": [
2327
+ null
2328
+ ],
2329
+ "load_eviction_policies": [
2330
+ "",
2331
+ "",
2332
+ ""
2333
+ ],
2334
+ "num_warps": 4,
2335
+ "num_stages": 1,
2336
+ "indexing": [
2337
+ "pointer",
2338
+ "pointer",
2339
+ "pointer",
2340
+ "pointer"
2341
+ ],
2342
+ "pid_type": "flat"
2343
+ }
2344
+ },
2345
+ {
2346
+ "key": {
2347
+ "intermediate": 4096,
2348
+ "numtokens": 32
2349
+ },
2350
+ "config": {
2351
+ "block_sizes": [
2352
+ 4,
2353
+ 4096
2354
+ ],
2355
+ "loop_orders": [
2356
+ [
2357
+ 0,
2358
+ 1
2359
+ ]
2360
+ ],
2361
+ "flatten_loops": [
2362
+ true
2363
+ ],
2364
+ "l2_groupings": [
2365
+ 16
2366
+ ],
2367
+ "range_unroll_factors": [
2368
+ 0
2369
+ ],
2370
+ "range_warp_specializes": [],
2371
+ "range_num_stages": [
2372
+ 0
2373
+ ],
2374
+ "range_multi_buffers": [
2375
+ null
2376
+ ],
2377
+ "range_flattens": [
2378
+ null
2379
+ ],
2380
+ "load_eviction_policies": [
2381
+ "first",
2382
+ "last",
2383
+ ""
2384
+ ],
2385
+ "num_warps": 32,
2386
+ "num_stages": 5,
2387
+ "indexing": [
2388
+ "pointer",
2389
+ "tensor_descriptor",
2390
+ "pointer",
2391
+ "pointer"
2392
+ ],
2393
+ "pid_type": "flat"
2394
+ }
2395
+ },
2396
+ {
2397
+ "key": {
2398
+ "intermediate": 8192,
2399
+ "numtokens": 32
2400
+ },
2401
+ "config": {
2402
+ "block_sizes": [
2403
+ 4,
2404
+ 1024
2405
+ ],
2406
+ "loop_orders": [
2407
+ [
2408
+ 0,
2409
+ 1
2410
+ ]
2411
+ ],
2412
+ "flatten_loops": [
2413
+ true
2414
+ ],
2415
+ "l2_groupings": [
2416
+ 2
2417
+ ],
2418
+ "range_unroll_factors": [
2419
+ 0
2420
+ ],
2421
+ "range_warp_specializes": [],
2422
+ "range_num_stages": [
2423
+ 0
2424
+ ],
2425
+ "range_multi_buffers": [
2426
+ null
2427
+ ],
2428
+ "range_flattens": [
2429
+ null
2430
+ ],
2431
+ "load_eviction_policies": [
2432
+ "",
2433
+ "last",
2434
+ ""
2435
+ ],
2436
+ "num_warps": 2,
2437
+ "num_stages": 3,
2438
+ "indexing": [
2439
+ "tensor_descriptor",
2440
+ "tensor_descriptor",
2441
+ "pointer",
2442
+ "tensor_descriptor"
2443
+ ],
2444
+ "pid_type": "flat"
2445
+ }
2446
+ },
2447
+ {
2448
+ "key": {
2449
+ "intermediate": 11008,
2450
+ "numtokens": 32
2451
+ },
2452
+ "config": {
2453
+ "block_sizes": [
2454
+ 2,
2455
+ 2048
2456
+ ],
2457
+ "loop_orders": [
2458
+ [
2459
+ 0,
2460
+ 1
2461
+ ]
2462
+ ],
2463
+ "flatten_loops": [
2464
+ true
2465
+ ],
2466
+ "l2_groupings": [
2467
+ 1
2468
+ ],
2469
+ "range_unroll_factors": [
2470
+ 0
2471
+ ],
2472
+ "range_warp_specializes": [],
2473
+ "range_num_stages": [
2474
+ 0
2475
+ ],
2476
+ "range_multi_buffers": [
2477
+ null
2478
+ ],
2479
+ "range_flattens": [
2480
+ null
2481
+ ],
2482
+ "load_eviction_policies": [
2483
+ "",
2484
+ "",
2485
+ ""
2486
+ ],
2487
+ "num_warps": 8,
2488
+ "num_stages": 1,
2489
+ "indexing": [
2490
+ "pointer",
2491
+ "pointer",
2492
+ "pointer",
2493
+ "pointer"
2494
+ ],
2495
+ "pid_type": "flat"
2496
+ }
2497
+ },
2498
+ {
2499
+ "key": {
2500
+ "intermediate": 14336,
2501
+ "numtokens": 32
2502
+ },
2503
+ "config": {
2504
+ "block_sizes": [
2505
+ 1,
2506
+ 512
2507
+ ],
2508
+ "loop_orders": [
2509
+ [
2510
+ 0,
2511
+ 1
2512
+ ]
2513
+ ],
2514
+ "flatten_loops": [
2515
+ true
2516
+ ],
2517
+ "l2_groupings": [
2518
+ 64
2519
+ ],
2520
+ "range_unroll_factors": [
2521
+ 0
2522
+ ],
2523
+ "range_warp_specializes": [],
2524
+ "range_num_stages": [
2525
+ 0
2526
+ ],
2527
+ "range_multi_buffers": [
2528
+ null
2529
+ ],
2530
+ "range_flattens": [
2531
+ null
2532
+ ],
2533
+ "load_eviction_policies": [
2534
+ "first",
2535
+ "",
2536
+ ""
2537
+ ],
2538
+ "num_warps": 4,
2539
+ "num_stages": 3,
2540
+ "indexing": [
2541
+ "pointer",
2542
+ "tensor_descriptor",
2543
+ "pointer",
2544
+ "pointer"
2545
+ ],
2546
+ "pid_type": "flat"
2547
+ }
2548
+ },
2549
+ {
2550
+ "key": {
2551
+ "intermediate": 2048,
2552
+ "numtokens": 40
2553
+ },
2554
+ "config": {
2555
+ "block_sizes": [
2556
+ 32,
2557
+ 32
2558
+ ],
2559
+ "loop_orders": [
2560
+ [
2561
+ 0,
2562
+ 1
2563
+ ]
2564
+ ],
2565
+ "flatten_loops": [
2566
+ true
2567
+ ],
2568
+ "l2_groupings": [
2569
+ 1
2570
+ ],
2571
+ "range_unroll_factors": [
2572
+ 0
2573
+ ],
2574
+ "range_warp_specializes": [],
2575
+ "range_num_stages": [
2576
+ 0
2577
+ ],
2578
+ "range_multi_buffers": [
2579
+ null
2580
+ ],
2581
+ "range_flattens": [
2582
+ null
2583
+ ],
2584
+ "load_eviction_policies": [
2585
+ "",
2586
+ "",
2587
+ ""
2588
+ ],
2589
+ "num_warps": 4,
2590
+ "num_stages": 1,
2591
+ "indexing": [
2592
+ "pointer",
2593
+ "pointer",
2594
+ "pointer",
2595
+ "pointer"
2596
+ ],
2597
+ "pid_type": "flat"
2598
+ }
2599
+ },
2600
+ {
2601
+ "key": {
2602
+ "intermediate": 2880,
2603
+ "numtokens": 40
2604
+ },
2605
+ "config": {
2606
+ "block_sizes": [
2607
+ 1,
2608
+ 4096
2609
+ ],
2610
+ "loop_orders": [
2611
+ [
2612
+ 1,
2613
+ 0
2614
+ ]
2615
+ ],
2616
+ "flatten_loops": [
2617
+ false
2618
+ ],
2619
+ "l2_groupings": [
2620
+ 32
2621
+ ],
2622
+ "range_unroll_factors": [
2623
+ 0
2624
+ ],
2625
+ "range_warp_specializes": [],
2626
+ "range_num_stages": [
2627
+ 0
2628
+ ],
2629
+ "range_multi_buffers": [
2630
+ null
2631
+ ],
2632
+ "range_flattens": [
2633
+ null
2634
+ ],
2635
+ "load_eviction_policies": [
2636
+ "",
2637
+ "last",
2638
+ "last"
2639
+ ],
2640
+ "num_warps": 8,
2641
+ "num_stages": 4,
2642
+ "indexing": [
2643
+ "tensor_descriptor",
2644
+ "pointer",
2645
+ "pointer",
2646
+ "pointer"
2647
+ ],
2648
+ "pid_type": "flat"
2649
+ }
2650
+ },
2651
+ {
2652
+ "key": {
2653
+ "intermediate": 4096,
2654
+ "numtokens": 40
2655
+ },
2656
+ "config": {
2657
+ "block_sizes": [
2658
+ 32,
2659
+ 64
2660
+ ],
2661
+ "loop_orders": [
2662
+ [
2663
+ 0,
2664
+ 1
2665
+ ]
2666
+ ],
2667
+ "flatten_loops": [
2668
+ true
2669
+ ],
2670
+ "l2_groupings": [
2671
+ 1
2672
+ ],
2673
+ "range_unroll_factors": [
2674
+ 0
2675
+ ],
2676
+ "range_warp_specializes": [],
2677
+ "range_num_stages": [
2678
+ 0
2679
+ ],
2680
+ "range_multi_buffers": [
2681
+ null
2682
+ ],
2683
+ "range_flattens": [
2684
+ null
2685
+ ],
2686
+ "load_eviction_policies": [
2687
+ "",
2688
+ "",
2689
+ ""
2690
+ ],
2691
+ "num_warps": 8,
2692
+ "num_stages": 1,
2693
+ "indexing": [
2694
+ "pointer",
2695
+ "pointer",
2696
+ "pointer",
2697
+ "pointer"
2698
+ ],
2699
+ "pid_type": "flat"
2700
+ }
2701
+ },
2702
+ {
2703
+ "key": {
2704
+ "intermediate": 8192,
2705
+ "numtokens": 40
2706
+ },
2707
+ "config": {
2708
+ "block_sizes": [
2709
+ 2,
2710
+ 256
2711
+ ],
2712
+ "loop_orders": [
2713
+ [
2714
+ 0,
2715
+ 1
2716
+ ]
2717
+ ],
2718
+ "flatten_loops": [
2719
+ true
2720
+ ],
2721
+ "l2_groupings": [
2722
+ 16
2723
+ ],
2724
+ "range_unroll_factors": [
2725
+ 0
2726
+ ],
2727
+ "range_warp_specializes": [],
2728
+ "range_num_stages": [
2729
+ 0
2730
+ ],
2731
+ "range_multi_buffers": [
2732
+ null
2733
+ ],
2734
+ "range_flattens": [
2735
+ null
2736
+ ],
2737
+ "load_eviction_policies": [
2738
+ "",
2739
+ "last",
2740
+ "last"
2741
+ ],
2742
+ "num_warps": 2,
2743
+ "num_stages": 2,
2744
+ "indexing": [
2745
+ "pointer",
2746
+ "pointer",
2747
+ "pointer",
2748
+ "tensor_descriptor"
2749
+ ],
2750
+ "pid_type": "flat"
2751
+ }
2752
+ },
2753
+ {
2754
+ "key": {
2755
+ "intermediate": 11008,
2756
+ "numtokens": 40
2757
+ },
2758
+ "config": {
2759
+ "block_sizes": [
2760
+ 16,
2761
+ 256
2762
+ ],
2763
+ "loop_orders": [
2764
+ [
2765
+ 0,
2766
+ 1
2767
+ ]
2768
+ ],
2769
+ "flatten_loops": [
2770
+ true
2771
+ ],
2772
+ "l2_groupings": [
2773
+ 1
2774
+ ],
2775
+ "range_unroll_factors": [
2776
+ 0
2777
+ ],
2778
+ "range_warp_specializes": [],
2779
+ "range_num_stages": [
2780
+ 0
2781
+ ],
2782
+ "range_multi_buffers": [
2783
+ null
2784
+ ],
2785
+ "range_flattens": [
2786
+ null
2787
+ ],
2788
+ "load_eviction_policies": [
2789
+ "",
2790
+ "",
2791
+ ""
2792
+ ],
2793
+ "num_warps": 8,
2794
+ "num_stages": 1,
2795
+ "indexing": [
2796
+ "pointer",
2797
+ "pointer",
2798
+ "pointer",
2799
+ "pointer"
2800
+ ],
2801
+ "pid_type": "flat"
2802
+ }
2803
+ },
2804
+ {
2805
+ "key": {
2806
+ "intermediate": 14336,
2807
+ "numtokens": 40
2808
+ },
2809
+ "config": {
2810
+ "block_sizes": [
2811
+ 4,
2812
+ 1024
2813
+ ],
2814
+ "loop_orders": [
2815
+ [
2816
+ 0,
2817
+ 1
2818
+ ]
2819
+ ],
2820
+ "flatten_loops": [
2821
+ true
2822
+ ],
2823
+ "l2_groupings": [
2824
+ 1
2825
+ ],
2826
+ "range_unroll_factors": [
2827
+ 0
2828
+ ],
2829
+ "range_warp_specializes": [],
2830
+ "range_num_stages": [
2831
+ 1
2832
+ ],
2833
+ "range_multi_buffers": [
2834
+ null
2835
+ ],
2836
+ "range_flattens": [
2837
+ null
2838
+ ],
2839
+ "load_eviction_policies": [
2840
+ "first",
2841
+ "",
2842
+ "last"
2843
+ ],
2844
+ "num_warps": 16,
2845
+ "num_stages": 5,
2846
+ "indexing": [
2847
+ "tensor_descriptor",
2848
+ "tensor_descriptor",
2849
+ "tensor_descriptor",
2850
+ "tensor_descriptor"
2851
+ ],
2852
+ "pid_type": "persistent_interleaved",
2853
+ "num_sm_multiplier": 32,
2854
+ "maxnreg": 32
2855
+ }
2856
+ },
2857
+ {
2858
+ "key": {
2859
+ "intermediate": 2048,
2860
+ "numtokens": 48
2861
+ },
2862
+ "config": {
2863
+ "block_sizes": [
2864
+ 32,
2865
+ 32
2866
+ ],
2867
+ "loop_orders": [
2868
+ [
2869
+ 0,
2870
+ 1
2871
+ ]
2872
+ ],
2873
+ "flatten_loops": [
2874
+ true
2875
+ ],
2876
+ "l2_groupings": [
2877
+ 1
2878
+ ],
2879
+ "range_unroll_factors": [
2880
+ 0
2881
+ ],
2882
+ "range_warp_specializes": [],
2883
+ "range_num_stages": [
2884
+ 0
2885
+ ],
2886
+ "range_multi_buffers": [
2887
+ null
2888
+ ],
2889
+ "range_flattens": [
2890
+ null
2891
+ ],
2892
+ "load_eviction_policies": [
2893
+ "",
2894
+ "",
2895
+ ""
2896
+ ],
2897
+ "num_warps": 4,
2898
+ "num_stages": 1,
2899
+ "indexing": [
2900
+ "pointer",
2901
+ "pointer",
2902
+ "pointer",
2903
+ "pointer"
2904
+ ],
2905
+ "pid_type": "flat"
2906
+ }
2907
+ },
2908
+ {
2909
+ "key": {
2910
+ "intermediate": 2880,
2911
+ "numtokens": 48
2912
+ },
2913
+ "config": {
2914
+ "block_sizes": [
2915
+ 16,
2916
+ 64
2917
+ ],
2918
+ "loop_orders": [
2919
+ [
2920
+ 0,
2921
+ 1
2922
+ ]
2923
+ ],
2924
+ "flatten_loops": [
2925
+ true
2926
+ ],
2927
+ "l2_groupings": [
2928
+ 1
2929
+ ],
2930
+ "range_unroll_factors": [
2931
+ 0
2932
+ ],
2933
+ "range_warp_specializes": [],
2934
+ "range_num_stages": [
2935
+ 0
2936
+ ],
2937
+ "range_multi_buffers": [
2938
+ null
2939
+ ],
2940
+ "range_flattens": [
2941
+ null
2942
+ ],
2943
+ "load_eviction_policies": [
2944
+ "",
2945
+ "",
2946
+ ""
2947
+ ],
2948
+ "num_warps": 4,
2949
+ "num_stages": 1,
2950
+ "indexing": [
2951
+ "pointer",
2952
+ "pointer",
2953
+ "pointer",
2954
+ "pointer"
2955
+ ],
2956
+ "pid_type": "flat"
2957
+ }
2958
+ },
2959
+ {
2960
+ "key": {
2961
+ "intermediate": 4096,
2962
+ "numtokens": 48
2963
+ },
2964
+ "config": {
2965
+ "block_sizes": [
2966
+ 32,
2967
+ 64
2968
+ ],
2969
+ "loop_orders": [
2970
+ [
2971
+ 0,
2972
+ 1
2973
+ ]
2974
+ ],
2975
+ "flatten_loops": [
2976
+ true
2977
+ ],
2978
+ "l2_groupings": [
2979
+ 1
2980
+ ],
2981
+ "range_unroll_factors": [
2982
+ 0
2983
+ ],
2984
+ "range_warp_specializes": [],
2985
+ "range_num_stages": [
2986
+ 0
2987
+ ],
2988
+ "range_multi_buffers": [
2989
+ null
2990
+ ],
2991
+ "range_flattens": [
2992
+ null
2993
+ ],
2994
+ "load_eviction_policies": [
2995
+ "",
2996
+ "",
2997
+ ""
2998
+ ],
2999
+ "num_warps": 8,
3000
+ "num_stages": 1,
3001
+ "indexing": [
3002
+ "pointer",
3003
+ "pointer",
3004
+ "pointer",
3005
+ "pointer"
3006
+ ],
3007
+ "pid_type": "flat"
3008
+ }
3009
+ },
3010
+ {
3011
+ "key": {
3012
+ "intermediate": 8192,
3013
+ "numtokens": 48
3014
+ },
3015
+ "config": {
3016
+ "block_sizes": [
3017
+ 1,
3018
+ 4096
3019
+ ],
3020
+ "loop_orders": [
3021
+ [
3022
+ 0,
3023
+ 1
3024
+ ]
3025
+ ],
3026
+ "flatten_loops": [
3027
+ true
3028
+ ],
3029
+ "l2_groupings": [
3030
+ 2
3031
+ ],
3032
+ "range_unroll_factors": [
3033
+ 0
3034
+ ],
3035
+ "range_warp_specializes": [],
3036
+ "range_num_stages": [
3037
+ 0
3038
+ ],
3039
+ "range_multi_buffers": [
3040
+ null
3041
+ ],
3042
+ "range_flattens": [
3043
+ null
3044
+ ],
3045
+ "load_eviction_policies": [
3046
+ "first",
3047
+ "",
3048
+ "last"
3049
+ ],
3050
+ "num_warps": 4,
3051
+ "num_stages": 2,
3052
+ "indexing": [
3053
+ "pointer",
3054
+ "tensor_descriptor",
3055
+ "tensor_descriptor",
3056
+ "pointer"
3057
+ ],
3058
+ "pid_type": "flat"
3059
+ }
3060
+ },
3061
+ {
3062
+ "key": {
3063
+ "intermediate": 11008,
3064
+ "numtokens": 48
3065
+ },
3066
+ "config": {
3067
+ "block_sizes": [
3068
+ 16,
3069
+ 256
3070
+ ],
3071
+ "loop_orders": [
3072
+ [
3073
+ 0,
3074
+ 1
3075
+ ]
3076
+ ],
3077
+ "flatten_loops": [
3078
+ true
3079
+ ],
3080
+ "l2_groupings": [
3081
+ 1
3082
+ ],
3083
+ "range_unroll_factors": [
3084
+ 0
3085
+ ],
3086
+ "range_warp_specializes": [],
3087
+ "range_num_stages": [
3088
+ 0
3089
+ ],
3090
+ "range_multi_buffers": [
3091
+ null
3092
+ ],
3093
+ "range_flattens": [
3094
+ null
3095
+ ],
3096
+ "load_eviction_policies": [
3097
+ "",
3098
+ "",
3099
+ ""
3100
+ ],
3101
+ "num_warps": 8,
3102
+ "num_stages": 1,
3103
+ "indexing": [
3104
+ "pointer",
3105
+ "pointer",
3106
+ "pointer",
3107
+ "pointer"
3108
+ ],
3109
+ "pid_type": "flat"
3110
+ }
3111
+ },
3112
+ {
3113
+ "key": {
3114
+ "intermediate": 14336,
3115
+ "numtokens": 48
3116
+ },
3117
+ "config": {
3118
+ "block_sizes": [
3119
+ 32,
3120
+ 256
3121
+ ],
3122
+ "loop_orders": [
3123
+ [
3124
+ 0,
3125
+ 1
3126
+ ]
3127
+ ],
3128
+ "flatten_loops": [
3129
+ true
3130
+ ],
3131
+ "l2_groupings": [
3132
+ 1
3133
+ ],
3134
+ "range_unroll_factors": [
3135
+ 0
3136
+ ],
3137
+ "range_warp_specializes": [],
3138
+ "range_num_stages": [
3139
+ 0
3140
+ ],
3141
+ "range_multi_buffers": [
3142
+ null
3143
+ ],
3144
+ "range_flattens": [
3145
+ null
3146
+ ],
3147
+ "load_eviction_policies": [
3148
+ "",
3149
+ "",
3150
+ ""
3151
+ ],
3152
+ "num_warps": 8,
3153
+ "num_stages": 1,
3154
+ "indexing": [
3155
+ "pointer",
3156
+ "pointer",
3157
+ "pointer",
3158
+ "pointer"
3159
+ ],
3160
+ "pid_type": "flat"
3161
+ }
3162
+ },
3163
+ {
3164
+ "key": {
3165
+ "intermediate": 2048,
3166
+ "numtokens": 56
3167
+ },
3168
+ "config": {
3169
+ "block_sizes": [
3170
+ 32,
3171
+ 32
3172
+ ],
3173
+ "loop_orders": [
3174
+ [
3175
+ 0,
3176
+ 1
3177
+ ]
3178
+ ],
3179
+ "flatten_loops": [
3180
+ true
3181
+ ],
3182
+ "l2_groupings": [
3183
+ 1
3184
+ ],
3185
+ "range_unroll_factors": [
3186
+ 0
3187
+ ],
3188
+ "range_warp_specializes": [],
3189
+ "range_num_stages": [
3190
+ 0
3191
+ ],
3192
+ "range_multi_buffers": [
3193
+ null
3194
+ ],
3195
+ "range_flattens": [
3196
+ null
3197
+ ],
3198
+ "load_eviction_policies": [
3199
+ "",
3200
+ "",
3201
+ ""
3202
+ ],
3203
+ "num_warps": 4,
3204
+ "num_stages": 1,
3205
+ "indexing": [
3206
+ "pointer",
3207
+ "pointer",
3208
+ "pointer",
3209
+ "pointer"
3210
+ ],
3211
+ "pid_type": "flat"
3212
+ }
3213
+ },
3214
+ {
3215
+ "key": {
3216
+ "intermediate": 2880,
3217
+ "numtokens": 56
3218
+ },
3219
+ "config": {
3220
+ "block_sizes": [
3221
+ 1,
3222
+ 2048
3223
+ ],
3224
+ "loop_orders": [
3225
+ [
3226
+ 0,
3227
+ 1
3228
+ ]
3229
+ ],
3230
+ "flatten_loops": [
3231
+ true
3232
+ ],
3233
+ "l2_groupings": [
3234
+ 1
3235
+ ],
3236
+ "range_unroll_factors": [
3237
+ 0
3238
+ ],
3239
+ "range_warp_specializes": [],
3240
+ "range_num_stages": [
3241
+ 0
3242
+ ],
3243
+ "range_multi_buffers": [
3244
+ null
3245
+ ],
3246
+ "range_flattens": [
3247
+ null
3248
+ ],
3249
+ "load_eviction_policies": [
3250
+ "",
3251
+ "",
3252
+ ""
3253
+ ],
3254
+ "num_warps": 8,
3255
+ "num_stages": 1,
3256
+ "indexing": [
3257
+ "pointer",
3258
+ "pointer",
3259
+ "pointer",
3260
+ "pointer"
3261
+ ],
3262
+ "pid_type": "flat"
3263
+ }
3264
+ },
3265
+ {
3266
+ "key": {
3267
+ "intermediate": 4096,
3268
+ "numtokens": 56
3269
+ },
3270
+ "config": {
3271
+ "block_sizes": [
3272
+ 32,
3273
+ 64
3274
+ ],
3275
+ "loop_orders": [
3276
+ [
3277
+ 0,
3278
+ 1
3279
+ ]
3280
+ ],
3281
+ "flatten_loops": [
3282
+ true
3283
+ ],
3284
+ "l2_groupings": [
3285
+ 1
3286
+ ],
3287
+ "range_unroll_factors": [
3288
+ 0
3289
+ ],
3290
+ "range_warp_specializes": [],
3291
+ "range_num_stages": [
3292
+ 0
3293
+ ],
3294
+ "range_multi_buffers": [
3295
+ null
3296
+ ],
3297
+ "range_flattens": [
3298
+ null
3299
+ ],
3300
+ "load_eviction_policies": [
3301
+ "",
3302
+ "",
3303
+ ""
3304
+ ],
3305
+ "num_warps": 8,
3306
+ "num_stages": 1,
3307
+ "indexing": [
3308
+ "pointer",
3309
+ "pointer",
3310
+ "pointer",
3311
+ "pointer"
3312
+ ],
3313
+ "pid_type": "flat"
3314
+ }
3315
+ },
3316
+ {
3317
+ "key": {
3318
+ "intermediate": 8192,
3319
+ "numtokens": 56
3320
+ },
3321
+ "config": {
3322
+ "block_sizes": [
3323
+ 32,
3324
+ 128
3325
+ ],
3326
+ "loop_orders": [
3327
+ [
3328
+ 0,
3329
+ 1
3330
+ ]
3331
+ ],
3332
+ "flatten_loops": [
3333
+ true
3334
+ ],
3335
+ "l2_groupings": [
3336
+ 1
3337
+ ],
3338
+ "range_unroll_factors": [
3339
+ 0
3340
+ ],
3341
+ "range_warp_specializes": [],
3342
+ "range_num_stages": [
3343
+ 0
3344
+ ],
3345
+ "range_multi_buffers": [
3346
+ null
3347
+ ],
3348
+ "range_flattens": [
3349
+ null
3350
+ ],
3351
+ "load_eviction_policies": [
3352
+ "",
3353
+ "",
3354
+ ""
3355
+ ],
3356
+ "num_warps": 8,
3357
+ "num_stages": 1,
3358
+ "indexing": [
3359
+ "pointer",
3360
+ "pointer",
3361
+ "pointer",
3362
+ "pointer"
3363
+ ],
3364
+ "pid_type": "flat"
3365
+ }
3366
+ },
3367
+ {
3368
+ "key": {
3369
+ "intermediate": 11008,
3370
+ "numtokens": 56
3371
+ },
3372
+ "config": {
3373
+ "block_sizes": [
3374
+ 1,
3375
+ 8192
3376
+ ],
3377
+ "loop_orders": [
3378
+ [
3379
+ 0,
3380
+ 1
3381
+ ]
3382
+ ],
3383
+ "flatten_loops": [
3384
+ true
3385
+ ],
3386
+ "l2_groupings": [
3387
+ 1
3388
+ ],
3389
+ "range_unroll_factors": [
3390
+ 0
3391
+ ],
3392
+ "range_warp_specializes": [],
3393
+ "range_num_stages": [
3394
+ 0
3395
+ ],
3396
+ "range_multi_buffers": [
3397
+ null
3398
+ ],
3399
+ "range_flattens": [
3400
+ null
3401
+ ],
3402
+ "load_eviction_policies": [
3403
+ "",
3404
+ "",
3405
+ ""
3406
+ ],
3407
+ "num_warps": 8,
3408
+ "num_stages": 1,
3409
+ "indexing": [
3410
+ "pointer",
3411
+ "pointer",
3412
+ "pointer",
3413
+ "pointer"
3414
+ ],
3415
+ "pid_type": "flat"
3416
+ }
3417
+ },
3418
+ {
3419
+ "key": {
3420
+ "intermediate": 14336,
3421
+ "numtokens": 56
3422
+ },
3423
+ "config": {
3424
+ "block_sizes": [
3425
+ 2,
3426
+ 4096
3427
+ ],
3428
+ "loop_orders": [
3429
+ [
3430
+ 0,
3431
+ 1
3432
+ ]
3433
+ ],
3434
+ "flatten_loops": [
3435
+ false
3436
+ ],
3437
+ "l2_groupings": [
3438
+ 32
3439
+ ],
3440
+ "range_unroll_factors": [
3441
+ 0
3442
+ ],
3443
+ "range_warp_specializes": [],
3444
+ "range_num_stages": [
3445
+ 0
3446
+ ],
3447
+ "range_multi_buffers": [
3448
+ null
3449
+ ],
3450
+ "range_flattens": [
3451
+ null
3452
+ ],
3453
+ "load_eviction_policies": [
3454
+ "first",
3455
+ "first",
3456
+ ""
3457
+ ],
3458
+ "num_warps": 2,
3459
+ "num_stages": 4,
3460
+ "indexing": [
3461
+ "tensor_descriptor",
3462
+ "pointer",
3463
+ "tensor_descriptor",
3464
+ "tensor_descriptor"
3465
+ ],
3466
+ "pid_type": "flat"
3467
+ }
3468
+ },
3469
+ {
3470
+ "key": {
3471
+ "intermediate": 2048,
3472
+ "numtokens": 64
3473
+ },
3474
+ "config": {
3475
+ "block_sizes": [
3476
+ 64,
3477
+ 32
3478
+ ],
3479
+ "loop_orders": [
3480
+ [
3481
+ 0,
3482
+ 1
3483
+ ]
3484
+ ],
3485
+ "flatten_loops": [
3486
+ true
3487
+ ],
3488
+ "l2_groupings": [
3489
+ 1
3490
+ ],
3491
+ "range_unroll_factors": [
3492
+ 0
3493
+ ],
3494
+ "range_warp_specializes": [],
3495
+ "range_num_stages": [
3496
+ 0
3497
+ ],
3498
+ "range_multi_buffers": [
3499
+ null
3500
+ ],
3501
+ "range_flattens": [
3502
+ null
3503
+ ],
3504
+ "load_eviction_policies": [
3505
+ "",
3506
+ "",
3507
+ ""
3508
+ ],
3509
+ "num_warps": 8,
3510
+ "num_stages": 1,
3511
+ "indexing": [
3512
+ "pointer",
3513
+ "pointer",
3514
+ "pointer",
3515
+ "pointer"
3516
+ ],
3517
+ "pid_type": "flat"
3518
+ }
3519
+ },
3520
+ {
3521
+ "key": {
3522
+ "intermediate": 2880,
3523
+ "numtokens": 64
3524
+ },
3525
+ "config": {
3526
+ "block_sizes": [
3527
+ 1,
3528
+ 2048
3529
+ ],
3530
+ "loop_orders": [
3531
+ [
3532
+ 0,
3533
+ 1
3534
+ ]
3535
+ ],
3536
+ "flatten_loops": [
3537
+ true
3538
+ ],
3539
+ "l2_groupings": [
3540
+ 1
3541
+ ],
3542
+ "range_unroll_factors": [
3543
+ 0
3544
+ ],
3545
+ "range_warp_specializes": [],
3546
+ "range_num_stages": [
3547
+ 0
3548
+ ],
3549
+ "range_multi_buffers": [
3550
+ null
3551
+ ],
3552
+ "range_flattens": [
3553
+ null
3554
+ ],
3555
+ "load_eviction_policies": [
3556
+ "",
3557
+ "",
3558
+ ""
3559
+ ],
3560
+ "num_warps": 8,
3561
+ "num_stages": 1,
3562
+ "indexing": [
3563
+ "pointer",
3564
+ "pointer",
3565
+ "pointer",
3566
+ "pointer"
3567
+ ],
3568
+ "pid_type": "flat"
3569
+ }
3570
+ },
3571
+ {
3572
+ "key": {
3573
+ "intermediate": 4096,
3574
+ "numtokens": 64
3575
+ },
3576
+ "config": {
3577
+ "block_sizes": [
3578
+ 64,
3579
+ 32
3580
+ ],
3581
+ "loop_orders": [
3582
+ [
3583
+ 0,
3584
+ 1
3585
+ ]
3586
+ ],
3587
+ "flatten_loops": [
3588
+ true
3589
+ ],
3590
+ "l2_groupings": [
3591
+ 1
3592
+ ],
3593
+ "range_unroll_factors": [
3594
+ 0
3595
+ ],
3596
+ "range_warp_specializes": [],
3597
+ "range_num_stages": [
3598
+ 0
3599
+ ],
3600
+ "range_multi_buffers": [
3601
+ null
3602
+ ],
3603
+ "range_flattens": [
3604
+ null
3605
+ ],
3606
+ "load_eviction_policies": [
3607
+ "",
3608
+ "",
3609
+ ""
3610
+ ],
3611
+ "num_warps": 8,
3612
+ "num_stages": 1,
3613
+ "indexing": [
3614
+ "pointer",
3615
+ "pointer",
3616
+ "pointer",
3617
+ "pointer"
3618
+ ],
3619
+ "pid_type": "flat"
3620
+ }
3621
+ },
3622
+ {
3623
+ "key": {
3624
+ "intermediate": 8192,
3625
+ "numtokens": 64
3626
+ },
3627
+ "config": {
3628
+ "block_sizes": [
3629
+ 64,
3630
+ 64
3631
+ ],
3632
+ "loop_orders": [
3633
+ [
3634
+ 0,
3635
+ 1
3636
+ ]
3637
+ ],
3638
+ "flatten_loops": [
3639
+ true
3640
+ ],
3641
+ "l2_groupings": [
3642
+ 1
3643
+ ],
3644
+ "range_unroll_factors": [
3645
+ 0
3646
+ ],
3647
+ "range_warp_specializes": [],
3648
+ "range_num_stages": [
3649
+ 0
3650
+ ],
3651
+ "range_multi_buffers": [
3652
+ null
3653
+ ],
3654
+ "range_flattens": [
3655
+ null
3656
+ ],
3657
+ "load_eviction_policies": [
3658
+ "",
3659
+ "",
3660
+ ""
3661
+ ],
3662
+ "num_warps": 8,
3663
+ "num_stages": 1,
3664
+ "indexing": [
3665
+ "pointer",
3666
+ "pointer",
3667
+ "pointer",
3668
+ "pointer"
3669
+ ],
3670
+ "pid_type": "flat"
3671
+ }
3672
+ },
3673
+ {
3674
+ "key": {
3675
+ "intermediate": 11008,
3676
+ "numtokens": 64
3677
+ },
3678
+ "config": {
3679
+ "block_sizes": [
3680
+ 1,
3681
+ 8192
3682
+ ],
3683
+ "loop_orders": [
3684
+ [
3685
+ 0,
3686
+ 1
3687
+ ]
3688
+ ],
3689
+ "flatten_loops": [
3690
+ true
3691
+ ],
3692
+ "l2_groupings": [
3693
+ 1
3694
+ ],
3695
+ "range_unroll_factors": [
3696
+ 0
3697
+ ],
3698
+ "range_warp_specializes": [],
3699
+ "range_num_stages": [
3700
+ 0
3701
+ ],
3702
+ "range_multi_buffers": [
3703
+ null
3704
+ ],
3705
+ "range_flattens": [
3706
+ null
3707
+ ],
3708
+ "load_eviction_policies": [
3709
+ "",
3710
+ "",
3711
+ ""
3712
+ ],
3713
+ "num_warps": 8,
3714
+ "num_stages": 1,
3715
+ "indexing": [
3716
+ "pointer",
3717
+ "pointer",
3718
+ "pointer",
3719
+ "pointer"
3720
+ ],
3721
+ "pid_type": "flat"
3722
+ }
3723
+ },
3724
+ {
3725
+ "key": {
3726
+ "intermediate": 14336,
3727
+ "numtokens": 64
3728
+ },
3729
+ "config": {
3730
+ "block_sizes": [
3731
+ 16,
3732
+ 512
3733
+ ],
3734
+ "loop_orders": [
3735
+ [
3736
+ 0,
3737
+ 1
3738
+ ]
3739
+ ],
3740
+ "flatten_loops": [
3741
+ true
3742
+ ],
3743
+ "l2_groupings": [
3744
+ 16
3745
+ ],
3746
+ "range_unroll_factors": [
3747
+ 0
3748
+ ],
3749
+ "range_warp_specializes": [],
3750
+ "range_num_stages": [
3751
+ 0
3752
+ ],
3753
+ "range_multi_buffers": [
3754
+ null
3755
+ ],
3756
+ "range_flattens": [
3757
+ null
3758
+ ],
3759
+ "load_eviction_policies": [
3760
+ "",
3761
+ "first",
3762
+ ""
3763
+ ],
3764
+ "num_warps": 4,
3765
+ "num_stages": 1,
3766
+ "indexing": [
3767
+ "pointer",
3768
+ "tensor_descriptor",
3769
+ "tensor_descriptor",
3770
+ "tensor_descriptor"
3771
+ ],
3772
+ "pid_type": "flat"
3773
+ }
3774
+ },
3775
+ {
3776
+ "key": {
3777
+ "intermediate": 2048,
3778
+ "numtokens": 72
3779
+ },
3780
+ "config": {
3781
+ "block_sizes": [
3782
+ 64,
3783
+ 32
3784
+ ],
3785
+ "loop_orders": [
3786
+ [
3787
+ 0,
3788
+ 1
3789
+ ]
3790
+ ],
3791
+ "flatten_loops": [
3792
+ true
3793
+ ],
3794
+ "l2_groupings": [
3795
+ 1
3796
+ ],
3797
+ "range_unroll_factors": [
3798
+ 0
3799
+ ],
3800
+ "range_warp_specializes": [],
3801
+ "range_num_stages": [
3802
+ 0
3803
+ ],
3804
+ "range_multi_buffers": [
3805
+ null
3806
+ ],
3807
+ "range_flattens": [
3808
+ null
3809
+ ],
3810
+ "load_eviction_policies": [
3811
+ "",
3812
+ "",
3813
+ ""
3814
+ ],
3815
+ "num_warps": 8,
3816
+ "num_stages": 1,
3817
+ "indexing": [
3818
+ "pointer",
3819
+ "pointer",
3820
+ "pointer",
3821
+ "pointer"
3822
+ ],
3823
+ "pid_type": "flat"
3824
+ }
3825
+ },
3826
+ {
3827
+ "key": {
3828
+ "intermediate": 2880,
3829
+ "numtokens": 72
3830
+ },
3831
+ "config": {
3832
+ "block_sizes": [
3833
+ 32,
3834
+ 64
3835
+ ],
3836
+ "loop_orders": [
3837
+ [
3838
+ 0,
3839
+ 1
3840
+ ]
3841
+ ],
3842
+ "flatten_loops": [
3843
+ true
3844
+ ],
3845
+ "l2_groupings": [
3846
+ 1
3847
+ ],
3848
+ "range_unroll_factors": [
3849
+ 0
3850
+ ],
3851
+ "range_warp_specializes": [],
3852
+ "range_num_stages": [
3853
+ 0
3854
+ ],
3855
+ "range_multi_buffers": [
3856
+ null
3857
+ ],
3858
+ "range_flattens": [
3859
+ null
3860
+ ],
3861
+ "load_eviction_policies": [
3862
+ "",
3863
+ "",
3864
+ ""
3865
+ ],
3866
+ "num_warps": 8,
3867
+ "num_stages": 1,
3868
+ "indexing": [
3869
+ "pointer",
3870
+ "pointer",
3871
+ "pointer",
3872
+ "pointer"
3873
+ ],
3874
+ "pid_type": "flat"
3875
+ }
3876
+ },
3877
+ {
3878
+ "key": {
3879
+ "intermediate": 4096,
3880
+ "numtokens": 72
3881
+ },
3882
+ "config": {
3883
+ "block_sizes": [
3884
+ 1,
3885
+ 1024
3886
+ ],
3887
+ "loop_orders": [
3888
+ [
3889
+ 0,
3890
+ 1
3891
+ ]
3892
+ ],
3893
+ "flatten_loops": [
3894
+ true
3895
+ ],
3896
+ "l2_groupings": [
3897
+ 4
3898
+ ],
3899
+ "range_unroll_factors": [
3900
+ 0
3901
+ ],
3902
+ "range_warp_specializes": [],
3903
+ "range_num_stages": [
3904
+ 0
3905
+ ],
3906
+ "range_multi_buffers": [
3907
+ null
3908
+ ],
3909
+ "range_flattens": [
3910
+ null
3911
+ ],
3912
+ "load_eviction_policies": [
3913
+ "",
3914
+ "",
3915
+ "first"
3916
+ ],
3917
+ "num_warps": 16,
3918
+ "num_stages": 2,
3919
+ "indexing": [
3920
+ "tensor_descriptor",
3921
+ "pointer",
3922
+ "pointer",
3923
+ "tensor_descriptor"
3924
+ ],
3925
+ "pid_type": "flat"
3926
+ }
3927
+ },
3928
+ {
3929
+ "key": {
3930
+ "intermediate": 8192,
3931
+ "numtokens": 72
3932
+ },
3933
+ "config": {
3934
+ "block_sizes": [
3935
+ 64,
3936
+ 128
3937
+ ],
3938
+ "loop_orders": [
3939
+ [
3940
+ 0,
3941
+ 1
3942
+ ]
3943
+ ],
3944
+ "flatten_loops": [
3945
+ true
3946
+ ],
3947
+ "l2_groupings": [
3948
+ 1
3949
+ ],
3950
+ "range_unroll_factors": [
3951
+ 0
3952
+ ],
3953
+ "range_warp_specializes": [],
3954
+ "range_num_stages": [
3955
+ 0
3956
+ ],
3957
+ "range_multi_buffers": [
3958
+ null
3959
+ ],
3960
+ "range_flattens": [
3961
+ null
3962
+ ],
3963
+ "load_eviction_policies": [
3964
+ "",
3965
+ "",
3966
+ ""
3967
+ ],
3968
+ "num_warps": 8,
3969
+ "num_stages": 1,
3970
+ "indexing": [
3971
+ "pointer",
3972
+ "pointer",
3973
+ "pointer",
3974
+ "pointer"
3975
+ ],
3976
+ "pid_type": "flat"
3977
+ }
3978
+ },
3979
+ {
3980
+ "key": {
3981
+ "intermediate": 11008,
3982
+ "numtokens": 72
3983
+ },
3984
+ "config": {
3985
+ "block_sizes": [
3986
+ 4,
3987
+ 256
3988
+ ],
3989
+ "loop_orders": [
3990
+ [
3991
+ 0,
3992
+ 1
3993
+ ]
3994
+ ],
3995
+ "flatten_loops": [
3996
+ true
3997
+ ],
3998
+ "l2_groupings": [
3999
+ 2
4000
+ ],
4001
+ "range_unroll_factors": [
4002
+ 0
4003
+ ],
4004
+ "range_warp_specializes": [],
4005
+ "range_num_stages": [
4006
+ 0
4007
+ ],
4008
+ "range_multi_buffers": [
4009
+ null
4010
+ ],
4011
+ "range_flattens": [
4012
+ null
4013
+ ],
4014
+ "load_eviction_policies": [
4015
+ "first",
4016
+ "last",
4017
+ "last"
4018
+ ],
4019
+ "num_warps": 32,
4020
+ "num_stages": 5,
4021
+ "indexing": [
4022
+ "pointer",
4023
+ "pointer",
4024
+ "tensor_descriptor",
4025
+ "tensor_descriptor"
4026
+ ],
4027
+ "pid_type": "flat"
4028
+ }
4029
+ },
4030
+ {
4031
+ "key": {
4032
+ "intermediate": 14336,
4033
+ "numtokens": 72
4034
+ },
4035
+ "config": {
4036
+ "block_sizes": [
4037
+ 32,
4038
+ 32
4039
+ ],
4040
+ "loop_orders": [
4041
+ [
4042
+ 0,
4043
+ 1
4044
+ ]
4045
+ ],
4046
+ "flatten_loops": [
4047
+ true
4048
+ ],
4049
+ "l2_groupings": [
4050
+ 2
4051
+ ],
4052
+ "range_unroll_factors": [
4053
+ 0
4054
+ ],
4055
+ "range_warp_specializes": [],
4056
+ "range_num_stages": [
4057
+ 0
4058
+ ],
4059
+ "range_multi_buffers": [
4060
+ null
4061
+ ],
4062
+ "range_flattens": [
4063
+ null
4064
+ ],
4065
+ "load_eviction_policies": [
4066
+ "last",
4067
+ "",
4068
+ "last"
4069
+ ],
4070
+ "num_warps": 8,
4071
+ "num_stages": 3,
4072
+ "indexing": [
4073
+ "pointer",
4074
+ "pointer",
4075
+ "tensor_descriptor",
4076
+ "pointer"
4077
+ ],
4078
+ "pid_type": "flat"
4079
+ }
4080
+ },
4081
+ {
4082
+ "key": {
4083
+ "intermediate": 2048,
4084
+ "numtokens": 80
4085
+ },
4086
+ "config": {
4087
+ "block_sizes": [
4088
+ 64,
4089
+ 32
4090
+ ],
4091
+ "loop_orders": [
4092
+ [
4093
+ 0,
4094
+ 1
4095
+ ]
4096
+ ],
4097
+ "flatten_loops": [
4098
+ true
4099
+ ],
4100
+ "l2_groupings": [
4101
+ 1
4102
+ ],
4103
+ "range_unroll_factors": [
4104
+ 0
4105
+ ],
4106
+ "range_warp_specializes": [],
4107
+ "range_num_stages": [
4108
+ 0
4109
+ ],
4110
+ "range_multi_buffers": [
4111
+ null
4112
+ ],
4113
+ "range_flattens": [
4114
+ null
4115
+ ],
4116
+ "load_eviction_policies": [
4117
+ "",
4118
+ "",
4119
+ ""
4120
+ ],
4121
+ "num_warps": 8,
4122
+ "num_stages": 1,
4123
+ "indexing": [
4124
+ "pointer",
4125
+ "pointer",
4126
+ "pointer",
4127
+ "pointer"
4128
+ ],
4129
+ "pid_type": "flat"
4130
+ }
4131
+ },
4132
+ {
4133
+ "key": {
4134
+ "intermediate": 2880,
4135
+ "numtokens": 80
4136
+ },
4137
+ "config": {
4138
+ "block_sizes": [
4139
+ 32,
4140
+ 64
4141
+ ],
4142
+ "loop_orders": [
4143
+ [
4144
+ 0,
4145
+ 1
4146
+ ]
4147
+ ],
4148
+ "flatten_loops": [
4149
+ true
4150
+ ],
4151
+ "l2_groupings": [
4152
+ 1
4153
+ ],
4154
+ "range_unroll_factors": [
4155
+ 0
4156
+ ],
4157
+ "range_warp_specializes": [],
4158
+ "range_num_stages": [
4159
+ 0
4160
+ ],
4161
+ "range_multi_buffers": [
4162
+ null
4163
+ ],
4164
+ "range_flattens": [
4165
+ null
4166
+ ],
4167
+ "load_eviction_policies": [
4168
+ "",
4169
+ "",
4170
+ ""
4171
+ ],
4172
+ "num_warps": 8,
4173
+ "num_stages": 1,
4174
+ "indexing": [
4175
+ "pointer",
4176
+ "pointer",
4177
+ "pointer",
4178
+ "pointer"
4179
+ ],
4180
+ "pid_type": "flat"
4181
+ }
4182
+ },
4183
+ {
4184
+ "key": {
4185
+ "intermediate": 4096,
4186
+ "numtokens": 80
4187
+ },
4188
+ "config": {
4189
+ "block_sizes": [
4190
+ 64,
4191
+ 64
4192
+ ],
4193
+ "loop_orders": [
4194
+ [
4195
+ 0,
4196
+ 1
4197
+ ]
4198
+ ],
4199
+ "flatten_loops": [
4200
+ true
4201
+ ],
4202
+ "l2_groupings": [
4203
+ 1
4204
+ ],
4205
+ "range_unroll_factors": [
4206
+ 0
4207
+ ],
4208
+ "range_warp_specializes": [],
4209
+ "range_num_stages": [
4210
+ 0
4211
+ ],
4212
+ "range_multi_buffers": [
4213
+ null
4214
+ ],
4215
+ "range_flattens": [
4216
+ null
4217
+ ],
4218
+ "load_eviction_policies": [
4219
+ "",
4220
+ "",
4221
+ ""
4222
+ ],
4223
+ "num_warps": 8,
4224
+ "num_stages": 1,
4225
+ "indexing": [
4226
+ "pointer",
4227
+ "pointer",
4228
+ "pointer",
4229
+ "pointer"
4230
+ ],
4231
+ "pid_type": "flat"
4232
+ }
4233
+ },
4234
+ {
4235
+ "key": {
4236
+ "intermediate": 8192,
4237
+ "numtokens": 80
4238
+ },
4239
+ "config": {
4240
+ "block_sizes": [
4241
+ 4,
4242
+ 128
4243
+ ],
4244
+ "loop_orders": [
4245
+ [
4246
+ 0,
4247
+ 1
4248
+ ]
4249
+ ],
4250
+ "flatten_loops": [
4251
+ true
4252
+ ],
4253
+ "l2_groupings": [
4254
+ 4
4255
+ ],
4256
+ "range_unroll_factors": [
4257
+ 0
4258
+ ],
4259
+ "range_warp_specializes": [],
4260
+ "range_num_stages": [
4261
+ 0
4262
+ ],
4263
+ "range_multi_buffers": [
4264
+ null
4265
+ ],
4266
+ "range_flattens": [
4267
+ null
4268
+ ],
4269
+ "load_eviction_policies": [
4270
+ "last",
4271
+ "last",
4272
+ "last"
4273
+ ],
4274
+ "num_warps": 16,
4275
+ "num_stages": 2,
4276
+ "indexing": [
4277
+ "pointer",
4278
+ "pointer",
4279
+ "pointer",
4280
+ "pointer"
4281
+ ],
4282
+ "pid_type": "flat"
4283
+ }
4284
+ },
4285
+ {
4286
+ "key": {
4287
+ "intermediate": 11008,
4288
+ "numtokens": 80
4289
+ },
4290
+ "config": {
4291
+ "block_sizes": [
4292
+ 1,
4293
+ 4096
4294
+ ],
4295
+ "loop_orders": [
4296
+ [
4297
+ 0,
4298
+ 1
4299
+ ]
4300
+ ],
4301
+ "flatten_loops": [
4302
+ true
4303
+ ],
4304
+ "l2_groupings": [
4305
+ 32
4306
+ ],
4307
+ "range_unroll_factors": [
4308
+ 0
4309
+ ],
4310
+ "range_warp_specializes": [],
4311
+ "range_num_stages": [
4312
+ 0
4313
+ ],
4314
+ "range_multi_buffers": [
4315
+ null
4316
+ ],
4317
+ "range_flattens": [
4318
+ null
4319
+ ],
4320
+ "load_eviction_policies": [
4321
+ "last",
4322
+ "last",
4323
+ ""
4324
+ ],
4325
+ "num_warps": 16,
4326
+ "num_stages": 2,
4327
+ "indexing": [
4328
+ "pointer",
4329
+ "tensor_descriptor",
4330
+ "tensor_descriptor",
4331
+ "tensor_descriptor"
4332
+ ],
4333
+ "pid_type": "flat"
4334
+ }
4335
+ },
4336
+ {
4337
+ "key": {
4338
+ "intermediate": 14336,
4339
+ "numtokens": 80
4340
+ },
4341
+ "config": {
4342
+ "block_sizes": [
4343
+ 2,
4344
+ 2048
4345
+ ],
4346
+ "loop_orders": [
4347
+ [
4348
+ 0,
4349
+ 1
4350
+ ]
4351
+ ],
4352
+ "flatten_loops": [
4353
+ true
4354
+ ],
4355
+ "l2_groupings": [
4356
+ 4
4357
+ ],
4358
+ "range_unroll_factors": [
4359
+ 0
4360
+ ],
4361
+ "range_warp_specializes": [],
4362
+ "range_num_stages": [
4363
+ 0
4364
+ ],
4365
+ "range_multi_buffers": [
4366
+ null
4367
+ ],
4368
+ "range_flattens": [
4369
+ null
4370
+ ],
4371
+ "load_eviction_policies": [
4372
+ "last",
4373
+ "last",
4374
+ ""
4375
+ ],
4376
+ "num_warps": 4,
4377
+ "num_stages": 6,
4378
+ "indexing": [
4379
+ "tensor_descriptor",
4380
+ "pointer",
4381
+ "pointer",
4382
+ "tensor_descriptor"
4383
+ ],
4384
+ "pid_type": "flat"
4385
+ }
4386
+ },
4387
+ {
4388
+ "key": {
4389
+ "intermediate": 2048,
4390
+ "numtokens": 88
4391
+ },
4392
+ "config": {
4393
+ "block_sizes": [
4394
+ 64,
4395
+ 32
4396
+ ],
4397
+ "loop_orders": [
4398
+ [
4399
+ 0,
4400
+ 1
4401
+ ]
4402
+ ],
4403
+ "flatten_loops": [
4404
+ true
4405
+ ],
4406
+ "l2_groupings": [
4407
+ 1
4408
+ ],
4409
+ "range_unroll_factors": [
4410
+ 0
4411
+ ],
4412
+ "range_warp_specializes": [],
4413
+ "range_num_stages": [
4414
+ 0
4415
+ ],
4416
+ "range_multi_buffers": [
4417
+ null
4418
+ ],
4419
+ "range_flattens": [
4420
+ null
4421
+ ],
4422
+ "load_eviction_policies": [
4423
+ "",
4424
+ "",
4425
+ ""
4426
+ ],
4427
+ "num_warps": 8,
4428
+ "num_stages": 1,
4429
+ "indexing": [
4430
+ "pointer",
4431
+ "pointer",
4432
+ "pointer",
4433
+ "pointer"
4434
+ ],
4435
+ "pid_type": "flat"
4436
+ }
4437
+ },
4438
+ {
4439
+ "key": {
4440
+ "intermediate": 2880,
4441
+ "numtokens": 88
4442
+ },
4443
+ "config": {
4444
+ "block_sizes": [
4445
+ 8,
4446
+ 256
4447
+ ],
4448
+ "loop_orders": [
4449
+ [
4450
+ 0,
4451
+ 1
4452
+ ]
4453
+ ],
4454
+ "flatten_loops": [
4455
+ true
4456
+ ],
4457
+ "l2_groupings": [
4458
+ 1
4459
+ ],
4460
+ "range_unroll_factors": [
4461
+ 0
4462
+ ],
4463
+ "range_warp_specializes": [],
4464
+ "range_num_stages": [
4465
+ 0
4466
+ ],
4467
+ "range_multi_buffers": [
4468
+ null
4469
+ ],
4470
+ "range_flattens": [
4471
+ null
4472
+ ],
4473
+ "load_eviction_policies": [
4474
+ "",
4475
+ "",
4476
+ ""
4477
+ ],
4478
+ "num_warps": 8,
4479
+ "num_stages": 1,
4480
+ "indexing": [
4481
+ "pointer",
4482
+ "pointer",
4483
+ "pointer",
4484
+ "pointer"
4485
+ ],
4486
+ "pid_type": "flat"
4487
+ }
4488
+ },
4489
+ {
4490
+ "key": {
4491
+ "intermediate": 4096,
4492
+ "numtokens": 88
4493
+ },
4494
+ "config": {
4495
+ "block_sizes": [
4496
+ 64,
4497
+ 64
4498
+ ],
4499
+ "loop_orders": [
4500
+ [
4501
+ 0,
4502
+ 1
4503
+ ]
4504
+ ],
4505
+ "flatten_loops": [
4506
+ true
4507
+ ],
4508
+ "l2_groupings": [
4509
+ 1
4510
+ ],
4511
+ "range_unroll_factors": [
4512
+ 0
4513
+ ],
4514
+ "range_warp_specializes": [],
4515
+ "range_num_stages": [
4516
+ 0
4517
+ ],
4518
+ "range_multi_buffers": [
4519
+ null
4520
+ ],
4521
+ "range_flattens": [
4522
+ null
4523
+ ],
4524
+ "load_eviction_policies": [
4525
+ "",
4526
+ "",
4527
+ ""
4528
+ ],
4529
+ "num_warps": 8,
4530
+ "num_stages": 1,
4531
+ "indexing": [
4532
+ "pointer",
4533
+ "pointer",
4534
+ "pointer",
4535
+ "pointer"
4536
+ ],
4537
+ "pid_type": "flat"
4538
+ }
4539
+ },
4540
+ {
4541
+ "key": {
4542
+ "intermediate": 8192,
4543
+ "numtokens": 88
4544
+ },
4545
+ "config": {
4546
+ "block_sizes": [
4547
+ 64,
4548
+ 128
4549
+ ],
4550
+ "loop_orders": [
4551
+ [
4552
+ 0,
4553
+ 1
4554
+ ]
4555
+ ],
4556
+ "flatten_loops": [
4557
+ true
4558
+ ],
4559
+ "l2_groupings": [
4560
+ 1
4561
+ ],
4562
+ "range_unroll_factors": [
4563
+ 0
4564
+ ],
4565
+ "range_warp_specializes": [],
4566
+ "range_num_stages": [
4567
+ 0
4568
+ ],
4569
+ "range_multi_buffers": [
4570
+ null
4571
+ ],
4572
+ "range_flattens": [
4573
+ null
4574
+ ],
4575
+ "load_eviction_policies": [
4576
+ "",
4577
+ "",
4578
+ ""
4579
+ ],
4580
+ "num_warps": 8,
4581
+ "num_stages": 1,
4582
+ "indexing": [
4583
+ "pointer",
4584
+ "pointer",
4585
+ "pointer",
4586
+ "pointer"
4587
+ ],
4588
+ "pid_type": "flat"
4589
+ }
4590
+ },
4591
+ {
4592
+ "key": {
4593
+ "intermediate": 11008,
4594
+ "numtokens": 88
4595
+ },
4596
+ "config": {
4597
+ "block_sizes": [
4598
+ 16,
4599
+ 2048
4600
+ ],
4601
+ "loop_orders": [
4602
+ [
4603
+ 0,
4604
+ 1
4605
+ ]
4606
+ ],
4607
+ "flatten_loops": [
4608
+ true
4609
+ ],
4610
+ "l2_groupings": [
4611
+ 2
4612
+ ],
4613
+ "range_unroll_factors": [
4614
+ 0
4615
+ ],
4616
+ "range_warp_specializes": [],
4617
+ "range_num_stages": [
4618
+ 0
4619
+ ],
4620
+ "range_multi_buffers": [
4621
+ null
4622
+ ],
4623
+ "range_flattens": [
4624
+ null
4625
+ ],
4626
+ "load_eviction_policies": [
4627
+ "first",
4628
+ "first",
4629
+ ""
4630
+ ],
4631
+ "num_warps": 32,
4632
+ "num_stages": 2,
4633
+ "indexing": [
4634
+ "tensor_descriptor",
4635
+ "tensor_descriptor",
4636
+ "pointer",
4637
+ "pointer"
4638
+ ],
4639
+ "pid_type": "flat"
4640
+ }
4641
+ },
4642
+ {
4643
+ "key": {
4644
+ "intermediate": 14336,
4645
+ "numtokens": 88
4646
+ },
4647
+ "config": {
4648
+ "block_sizes": [
4649
+ 4,
4650
+ 512
4651
+ ],
4652
+ "loop_orders": [
4653
+ [
4654
+ 0,
4655
+ 1
4656
+ ]
4657
+ ],
4658
+ "flatten_loops": [
4659
+ true
4660
+ ],
4661
+ "l2_groupings": [
4662
+ 16
4663
+ ],
4664
+ "range_unroll_factors": [
4665
+ 0
4666
+ ],
4667
+ "range_warp_specializes": [],
4668
+ "range_num_stages": [
4669
+ 0
4670
+ ],
4671
+ "range_multi_buffers": [
4672
+ null
4673
+ ],
4674
+ "range_flattens": [
4675
+ null
4676
+ ],
4677
+ "load_eviction_policies": [
4678
+ "",
4679
+ "",
4680
+ ""
4681
+ ],
4682
+ "num_warps": 32,
4683
+ "num_stages": 5,
4684
+ "indexing": [
4685
+ "pointer",
4686
+ "pointer",
4687
+ "pointer",
4688
+ "pointer"
4689
+ ],
4690
+ "pid_type": "flat"
4691
+ }
4692
+ },
4693
+ {
4694
+ "key": {
4695
+ "intermediate": 2048,
4696
+ "numtokens": 96
4697
+ },
4698
+ "config": {
4699
+ "block_sizes": [
4700
+ 64,
4701
+ 32
4702
+ ],
4703
+ "loop_orders": [
4704
+ [
4705
+ 0,
4706
+ 1
4707
+ ]
4708
+ ],
4709
+ "flatten_loops": [
4710
+ true
4711
+ ],
4712
+ "l2_groupings": [
4713
+ 1
4714
+ ],
4715
+ "range_unroll_factors": [
4716
+ 0
4717
+ ],
4718
+ "range_warp_specializes": [],
4719
+ "range_num_stages": [
4720
+ 0
4721
+ ],
4722
+ "range_multi_buffers": [
4723
+ null
4724
+ ],
4725
+ "range_flattens": [
4726
+ null
4727
+ ],
4728
+ "load_eviction_policies": [
4729
+ "",
4730
+ "",
4731
+ ""
4732
+ ],
4733
+ "num_warps": 8,
4734
+ "num_stages": 1,
4735
+ "indexing": [
4736
+ "pointer",
4737
+ "pointer",
4738
+ "pointer",
4739
+ "pointer"
4740
+ ],
4741
+ "pid_type": "flat"
4742
+ }
4743
+ },
4744
+ {
4745
+ "key": {
4746
+ "intermediate": 2880,
4747
+ "numtokens": 96
4748
+ },
4749
+ "config": {
4750
+ "block_sizes": [
4751
+ 32,
4752
+ 64
4753
+ ],
4754
+ "loop_orders": [
4755
+ [
4756
+ 0,
4757
+ 1
4758
+ ]
4759
+ ],
4760
+ "flatten_loops": [
4761
+ true
4762
+ ],
4763
+ "l2_groupings": [
4764
+ 1
4765
+ ],
4766
+ "range_unroll_factors": [
4767
+ 0
4768
+ ],
4769
+ "range_warp_specializes": [],
4770
+ "range_num_stages": [
4771
+ 0
4772
+ ],
4773
+ "range_multi_buffers": [
4774
+ null
4775
+ ],
4776
+ "range_flattens": [
4777
+ null
4778
+ ],
4779
+ "load_eviction_policies": [
4780
+ "",
4781
+ "",
4782
+ ""
4783
+ ],
4784
+ "num_warps": 8,
4785
+ "num_stages": 1,
4786
+ "indexing": [
4787
+ "pointer",
4788
+ "pointer",
4789
+ "pointer",
4790
+ "pointer"
4791
+ ],
4792
+ "pid_type": "flat"
4793
+ }
4794
+ },
4795
+ {
4796
+ "key": {
4797
+ "intermediate": 4096,
4798
+ "numtokens": 96
4799
+ },
4800
+ "config": {
4801
+ "block_sizes": [
4802
+ 1,
4803
+ 4096
4804
+ ],
4805
+ "loop_orders": [
4806
+ [
4807
+ 1,
4808
+ 0
4809
+ ]
4810
+ ],
4811
+ "flatten_loops": [
4812
+ false
4813
+ ],
4814
+ "l2_groupings": [
4815
+ 64
4816
+ ],
4817
+ "range_unroll_factors": [
4818
+ 0
4819
+ ],
4820
+ "range_warp_specializes": [],
4821
+ "range_num_stages": [
4822
+ 0
4823
+ ],
4824
+ "range_multi_buffers": [
4825
+ null
4826
+ ],
4827
+ "range_flattens": [
4828
+ null
4829
+ ],
4830
+ "load_eviction_policies": [
4831
+ "first",
4832
+ "last",
4833
+ "last"
4834
+ ],
4835
+ "num_warps": 4,
4836
+ "num_stages": 6,
4837
+ "indexing": [
4838
+ "pointer",
4839
+ "pointer",
4840
+ "tensor_descriptor",
4841
+ "pointer"
4842
+ ],
4843
+ "pid_type": "flat"
4844
+ }
4845
+ },
4846
+ {
4847
+ "key": {
4848
+ "intermediate": 8192,
4849
+ "numtokens": 96
4850
+ },
4851
+ "config": {
4852
+ "block_sizes": [
4853
+ 64,
4854
+ 128
4855
+ ],
4856
+ "loop_orders": [
4857
+ [
4858
+ 0,
4859
+ 1
4860
+ ]
4861
+ ],
4862
+ "flatten_loops": [
4863
+ true
4864
+ ],
4865
+ "l2_groupings": [
4866
+ 1
4867
+ ],
4868
+ "range_unroll_factors": [
4869
+ 0
4870
+ ],
4871
+ "range_warp_specializes": [],
4872
+ "range_num_stages": [
4873
+ 0
4874
+ ],
4875
+ "range_multi_buffers": [
4876
+ null
4877
+ ],
4878
+ "range_flattens": [
4879
+ null
4880
+ ],
4881
+ "load_eviction_policies": [
4882
+ "",
4883
+ "",
4884
+ ""
4885
+ ],
4886
+ "num_warps": 8,
4887
+ "num_stages": 1,
4888
+ "indexing": [
4889
+ "pointer",
4890
+ "pointer",
4891
+ "pointer",
4892
+ "pointer"
4893
+ ],
4894
+ "pid_type": "flat"
4895
+ }
4896
+ },
4897
+ {
4898
+ "key": {
4899
+ "intermediate": 11008,
4900
+ "numtokens": 96
4901
+ },
This file is too large to show in full.
vllm/kernels/helion/ops/silu_mul_fp8.py
+32
-31
@@ -1,11 +1,13 @@
1
# SPDX-License-Identifier: Apache-2.0
2
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
3
4
+from __future__ import annotations
5
+
6
from typing import Any
7
6
-import regex as re
8
import torch
9
10
+from vllm.kernels.helion.case_key import CaseKey
11
from vllm.logger import init_logger
12
from vllm.utils.import_utils import has_helion
13
@@ -22,14 +24,14 @@ from vllm.kernels.helion.register import register_kernel
24
logger = init_logger(__name__)
25
26
25
-def generate_silu_mul_fp8_inputs() -> dict[str, tuple[Any, ...]]:
27
+def generate_silu_mul_fp8_inputs() -> dict[CaseKey, tuple[Any, ...]]:
28
intermediate_sizes = [2048, 2880, 4096, 8192, 11008, 14336]
29
30
# Use the same num_tokens values as vLLM's default cudagraph capture sizes.
31
# See vllm/config/vllm.py _set_cudagraph_sizes() for the canonical formula.
32
num_tokens_list = [1, 2, 4] + list(range(8, 256, 8)) + list(range(256, 513, 16))
33
32
- inputs = {}
34
+ inputs: dict[CaseKey, tuple[Any, ...]] = {}
35
for num_tokens in num_tokens_list:
36
for intermediate_size in intermediate_sizes:
37
input_tensor = torch.randn(
@@ -40,15 +42,18 @@ def generate_silu_mul_fp8_inputs() -> dict[str, tuple[Any, ...]]:
42
)
43
scale = torch.tensor([1.0], device="cuda", dtype=torch.float32)
44
43
- config_key = f"intermediate_{intermediate_size}_numtokens_{num_tokens}"
44
- inputs[config_key] = (input_tensor, scale)
45
+ key = CaseKey({"intermediate": intermediate_size, "numtokens": num_tokens})
46
+ inputs[key] = (input_tensor, scale)
47
48
return inputs
49
50
51
+_pick_cache: dict[tuple[int, int], CaseKey | None] = {}
52
+
53
+
54
def pick_silu_mul_fp8_config(
50
- args: tuple[Any, ...], config_keys: list[str]
51
-) -> str | None:
55
+ args: tuple[Any, ...], config_keys: list[CaseKey]
56
+) -> CaseKey | None:
57
"""Pick the best pre-tuned config for the given input shape.
58
59
Selection strategy:
@@ -57,39 +62,35 @@ def pick_silu_mul_fp8_config(
62
2. Among the num_tokens values tuned for that intermediate_size, pick
63
the smallest num_tokens >= the input's num_tokens. If the input is
64
larger than all available num_tokens, fall back to the largest.
60
-
61
- Config keys must be "default" or follow the format
62
- "intermediate_{int}_numtokens_{int}".
65
"""
66
if not config_keys:
67
return None
68
69
input_tensor, _scale = args
68
- intermediate_size = input_tensor.shape[-1] // 2
69
- num_tokens = input_tensor.view(-1, input_tensor.shape[-1]).shape[0]
70
- configs: dict[int, list[int]] = {}
71
- for key in config_keys:
72
- if key == "default":
70
+ intermediate_size = int(input_tensor.shape[-1]) // 2
71
+ num_tokens = int(input_tensor.view(-1, input_tensor.shape[-1]).shape[0])
72
+
73
+ cache_key = (num_tokens, intermediate_size)
74
+ cached = _pick_cache.get(cache_key)
75
+ if cached is not None:
76
+ return cached
77
+
78
+ by_isize: dict[int, list[int]] = {}
79
+ for k in config_keys:
80
+ if k.is_default():
81
continue
74
- match = re.fullmatch(r"intermediate_(\d+)_numtokens_(\d+)", key)
75
- if not match:
76
- raise ValueError(
77
- f"Malformed config key '{key}', "
78
- f"expected format 'intermediate_{{int}}_numtokens_{{int}}'"
79
- )
80
- isize_str, ntokens_str = match.groups()
81
- configs.setdefault(int(isize_str), []).append(int(ntokens_str))
82
+ by_isize.setdefault(k["intermediate"], []).append(k["numtokens"])
83
83
- if not configs:
84
- return "default" if "default" in config_keys else None
84
+ if not by_isize:
85
+ return None
86
86
- best_isize = min(configs, key=lambda s: abs(s - intermediate_size))
87
- available_ntokens = sorted(configs[best_isize])
88
- best_ntokens = next(
89
- (n for n in available_ntokens if n >= num_tokens), available_ntokens[-1]
90
- )
87
+ best_isize = min(by_isize, key=lambda s: abs(s - intermediate_size))
88
+ available = sorted(by_isize[best_isize])
89
+ best_ntokens = next((n for n in available if n >= num_tokens), available[-1])
90
92
- return f"intermediate_{best_isize}_numtokens_{best_ntokens}"
91
+ result = CaseKey({"intermediate": best_isize, "numtokens": best_ntokens})
92
+ _pick_cache[cache_key] = result
93
+ return result
94
95
96
@register_kernel(
vllm/kernels/helion/register.py
+50
-50
@@ -36,12 +36,15 @@ Key Classes
36
- PresetConfigSearch: Custom autotuner that returns pre-tuned configs
37
"""
38
39
+from __future__ import annotations
40
+
41
from collections.abc import Callable
40
-from typing import Any, cast
42
+from typing import Any
43
44
import torch
45
from torch.library import Library
46
47
+from vllm.kernels.helion.case_key import CaseKey
48
from vllm.logger import init_logger
49
from vllm.utils.import_utils import has_helion
50
from vllm.utils.torch_utils import direct_register_custom_op
@@ -76,9 +79,11 @@ logger = init_logger(__name__)
79
80
vllm_helion_lib = Library("vllm_helion", "FRAGMENT") # noqa
81
82
+ConfigPicker = Callable[[tuple[Any, ...], list[CaseKey]], CaseKey | None]
83
+
84
85
def validate_helion_settings(
81
- helion_settings: "helion.Settings | None", op_name: str
86
+ helion_settings: helion.Settings | None, op_name: str
87
) -> None:
88
if helion_settings is None:
89
return
@@ -107,7 +112,7 @@ def validate_helion_settings(
112
113
def create_helion_decorated_kernel(
114
raw_kernel_func: Callable,
110
- helion_settings: "helion.Settings | None" = None,
115
+ helion_settings: helion.Settings | None = None,
116
extra_kwargs: dict[str, Any] | None = None,
117
) -> Any:
118
kernel_kwargs: dict[str, Any] = {}
@@ -144,9 +149,9 @@ class ConfiguredHelionKernel:
149
def __init__(
150
self,
151
op_name: str,
147
- config_picker: Callable[[tuple[Any, ...], list[str]], str | None] | None,
152
+ config_picker: ConfigPicker | None,
153
raw_kernel_func: Callable,
149
- helion_settings: "helion.Settings | None" = None,
154
+ helion_settings: helion.Settings | None = None,
155
):
156
self.op_name = op_name
157
self.config_picker = config_picker
@@ -170,41 +175,44 @@ class ConfiguredHelionKernel:
175
f"A config_picker must be provided to register_kernel()."
176
)
177
173
- # After None check, config_picker is guaranteed to be non-None
174
- assert self.config_picker is not None
178
+ picker = self.config_picker
179
+ all_keys = list(self.configs.keys())
180
+ default = CaseKey.default()
181
+ has_default = default in self.configs
182
183
def key_computer(*args):
177
- config_keys = list(self.configs.keys())
178
- # Cast is safe because we checked for None above
179
- config_picker = cast(
180
- Callable[[tuple[Any, ...], list[str]], str | None], self.config_picker
181
- )
182
- selected_key = config_picker(args, config_keys)
183
- if selected_key:
184
- return selected_key
185
- return "default" if "default" in self.configs else None
184
+ selected = picker(args, all_keys)
185
+ if selected is not None:
186
+ return str(selected)
187
+ if has_default:
188
+ return str(default)
189
+ return None
190
191
return key_computer
192
193
def _create_config_selector(self, key_computer):
194
+ str_to_key = {str(k): k for k in self.configs}
195
+
196
def config_selector(args):
191
- # args is a tuple; key_computer expects unpacked args
192
- selected_config_key = key_computer(*args)
197
+ selected_str = key_computer(*args)
198
194
- if selected_config_key is None:
199
+ if selected_str is None:
200
raise ValueError(
196
- f"Config picker returned None for kernel '{self.op_name}' "
197
- f"with available config keys: {list(self.configs.keys())}"
201
+ f"Config picker returned None for kernel "
202
+ f"'{self.op_name}' with available config keys: "
203
+ f"{list(self.configs.keys())}"
204
)
205
200
- if selected_config_key not in self.configs:
206
+ config_key = str_to_key.get(selected_str)
207
+ if config_key is None:
208
raise ValueError(
209
f"Config picker returned invalid config key "
203
- f"'{selected_config_key}' for kernel '{self.op_name}'. "
210
+ f"'{selected_str}' for kernel "
211
+ f"'{self.op_name}'. "
212
f"Available keys: {list(self.configs.keys())}"
213
)
214
207
- return self.configs[selected_config_key]
215
+ return self.configs[config_key]
216
217
return config_selector
218
@@ -251,9 +259,9 @@ class HelionKernelWrapper:
259
raw_kernel_func: Callable,
260
op_name: str,
261
fake_impl: Callable,
254
- config_picker: Callable[[tuple[Any, ...], list[str]], str | None],
255
- helion_settings: "helion.Settings | None" = None,
256
- input_generator: Callable[[], dict[str, tuple[Any, ...]]] | None = None,
262
+ config_picker: ConfigPicker,
263
+ helion_settings: helion.Settings | None = None,
264
+ input_generator: (Callable[[], dict[CaseKey, tuple[Any, ...]]] | None) = None,
265
):
266
# Validate helion_settings doesn't conflict with our custom autotuner
267
validate_helion_settings(helion_settings, op_name)
@@ -302,7 +310,7 @@ class HelionKernelWrapper:
310
# During eager execution, call the kernel directly.
311
return self._configured_kernel(*args, **kwargs)
312
305
- def get_inputs(self) -> dict[str, tuple[Any, ...]]:
313
+ def get_inputs(self) -> dict[CaseKey, tuple[Any, ...]]:
314
if self._input_generator is None:
315
raise NotImplementedError(
316
f"No input generator registered for kernel '{self.op_name}'. "
@@ -370,7 +378,7 @@ def get_kernel_by_name(kernel_name: str) -> HelionKernelWrapper | None:
378
379
def infer_fake_impl(
380
kernel_func: Callable,
373
- helion_settings: "helion.Settings | None" = None,
381
+ helion_settings: helion.Settings | None = None,
382
) -> Callable:
383
def helion_fake_kernel(*args, **kwargs):
384
kernel_kwargs = {}
@@ -392,37 +400,29 @@ def infer_fake_impl(
400
def register_kernel(
401
op_name: str | None = None,
402
*,
395
- config_picker: Callable[[tuple[Any, ...], list[str]], str | None],
403
+ config_picker: ConfigPicker,
404
fake_impl: Callable | None = None,
397
- helion_settings: "helion.Settings | None" = None,
398
- input_generator: Callable[[], dict[str, tuple[Any, ...]]] | None = None,
405
+ helion_settings: helion.Settings | None = None,
406
+ input_generator: (Callable[[], dict[CaseKey, tuple[Any, ...]]] | None) = None,
407
) -> Callable[[Callable], HelionKernelWrapper]:
408
"""Register a Helion kernel with pre-tuned config selection.
409
402
- Wraps the kernel function in a HelionKernelWrapper that eagerly builds
403
- the configured kernel and (on older PyTorch) registers a custom op.
404
-
410
Args:
406
- config_picker: Required. Function with signature
407
- ``(args: tuple, config_keys: list[str]) -> str | None``
408
- that picks the best config key from available options.
409
- Return ``None`` to fall back to ``"default"``.
411
+ config_picker: Required. Receives ``(args, config_keys)``
412
+ where each config key is a ``dict[str, Any]`` mapping
413
+ parameter names to values. Return the best-matching
414
+ dict, or ``None`` to fall back to the default config.
415
416
Example::
417
418
def pick_config(args, config_keys):
419
x = args[0]
415
- hidden_size = x.shape[-1]
416
- batch_size = x.shape[0]
417
- for key in config_keys:
418
- if key == f"hiddensize_{hidden_size}_batchsize_{batch_size}":
419
- return key
420
- return "default" if "default" in config_keys else None
421
-
422
- input_generator: Optional. Function that returns
423
- ``dict[str, tuple]`` where each key is a configuration
424
- identifier (e.g. ``"4096"``, ``"hidden_4096"``) and each
425
- value is a tuple of arguments to pass to the kernel.
420
+ best = min(config_keys, key=lambda k: abs(k["size"] - x.shape[0]))
421
+ return best
422
+
423
+ input_generator: Optional. Returns ``dict[str, tuple]`` where
424
+ each key is a serialized config key and each value is a
425
+ tuple of arguments to pass to the kernel.
426
427
Example::
428