Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@benchmarks/bench_gdn_prefill_cutile_vs_fla_blackwell.py`:
- Around line 41-71: Move the cuTile/sglang bootstrap out of top-level import so
it only runs when cuTile is actually available: read the root from an env/config
variable (use _SGLANG_ROOT from os.environ or a config fallback) instead of the
hard-coded Path, check CT_AVAILABLE (or validate that the configured
_SGLANG_ROOT exists and contains the expected files) before calling _stub/_load,
and wrap the for-loop that imports "sglang.srt.layers.attention.fla.*" inside
that availability guard; also make _load/_stub resilient by catching and
silencing file-not-found/import errors so the module import will cleanly report
cuTile unavailable rather than crashing.
- Around line 223-226: The call to _check_sm100() assigns is_sm100 but the
script continues even when it returns False, leaving an unused-variable (Ruff
F841) and allowing unsupported GPUs to proceed; change the logic after calling
_check_sm100() so that if it returns False you immediately stop the run (e.g.,
call sys.exit(1) or raise SystemExit) with a clear error message, otherwise
continue and print the GPU info—this both uses the return value and prevents
running the Blackwell-only path on unsupported hardware.

In `@flashinfer/gdn_kernels/cutile_gdn_prefill.py`:
- Around line 249-253: The optional initial_state/initial_state_indices path is
broken because USE_INITIAL only gates the load but both recurrence kernels
always write back into initial_state/initial_state_indices; fix by allocating
internal zero tensors when initial_state or initial_state_indices is None
instead of assuming callers supply them. In the functions that call the CUDA
kernels (e.g., chunk_gated_delta_rule and the other entrypoints around the shown
regions), detect if initial_state is None or initial_state_indices is None and
create zero tensors with the correct shape, device and dtype (initial_state:
[N,H,K,V]; initial_state_indices matching expected index shape), then pass those
buffers into the kernels so the write-back has a valid destination;
alternatively, remove Optional typing and require callers to pass buffers, but
prefer the internal-allocation approach so semantics match existing API. Ensure
allocations respect cu_seqlens / batch size and preserve device/dtype.
- Around line 196-205: The module-level scratch state (_tensor_cache,
_cache_config, _cached_stream) makes the exported kernel non-reentrant; change
the caching to be scoped per-call or at least per-device+stream. Update
_init_cache and callers (e.g., functions that use
_tensor_cache/_cache_config/_cached_stream) to accept a stream identifier and
include it in the cache key (for example key =
(B,T,H,K,V,device,dtype_k,dtype_v,stream)) or replace the globals with a
per-call local cache returned by _init_cache; ensure every read/write of
_tensor_cache/_cache_config/_cached_stream is replaced with lookups into the new
keyed dict or the returned local cache so concurrent invocations on the same
device but different streams do not collide.
- Around line 23-30: The import fallback sets ct = None which causes
AttributeError when module-level code later calls or uses `@ct.kernel`; instead
create a lightweight sentinel that raises ImportError when its kernel attribute
is accessed/used so the optional-import pattern behaves correctly. Replace the
except ImportError block so that CUTILE_AVAILABLE=False and ct is an object
(e.g., a small class instance or SimpleNamespace) that defines a kernel
attribute (callable/decorator) which, when invoked, raises
ImportError("cuda.tile not available"), and set Const to a similar sentinel or
None-consistent value; this ensures all module-level uses of ct.kernel and
references to Const (the symbols ct.kernel and Const) raise ImportError rather
than AttributeError during import.

In `@tests/gdn/test_prefill_cutile_blackwell.py`:
- Around line 29-30: Replace the local CUDA wrapper and manual major-version
check with the repo helpers: import flashinfer.utils.get_compute_capability and
flashinfer.utils.is_sm100a_supported, remove the local
get_compute_capability(device) that calls torch.cuda.get_device_capability, and
replace any checks like cc[0] != 10 with a call to
is_sm100a_supported(get_compute_capability(device)) (or its negation) to decide
skips; apply the same replacement for the other skip block referenced (the logic
around the cc checks at the later block).

Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@benchmarks/bench_gdn_prefill_cutile_vs_fla_blackwell.py`:
- Around line 299-318: The breakdown block has three issues: the inline lambda
fn_ct captures variables by reference (fragile), it re-imports
torch.nn.functional as F2 (redundant with F), and duplicates tensor setup
already present in bench_config; fix by replacing the lambda with a bound
callable (use functools.partial or a small local def that takes no args) that
binds q_n, k_n, v, g, beta, h0, idx and the scalar K**-0.5 at definition time
(reference: fn_ct and _profiler_breakdown), remove the redundant import F2 and
use the existing F, and DRY the tensor construction by reusing or extracting the
tensor creation into a helper referenced by the benchmark config so the same
tensors are built once and reused for the breakdown run.
- Around line 222-238: The assigned lambda functions fn_ct and fn_fla trigger
lint E731; replace them with named functions to improve clarity and stack
traces: create a def (e.g., def fn_ct(): ...) that calls ct_fwd with the same
arguments (q_n, k_n, v, g, beta, scale, h0.clone(), idx,
use_qk_l2norm_in_kernel=False) and another def fn_fla(): ... that calls fla_fwd
with the same keyword args (initial_state=h0.clone(), output_final_state=False),
then pass those function names into _profiler_time_us and _wallclock_time_us
instead of the lambdas.
- Around line 262-266: The current module-level import of cuda.tile silently
swallows exceptions (try: import cuda.tile as _ct; print(f"cuda.tile version:
{_ct.__version__}") except Exception: pass); change the except to capture the
exception (except Exception as e:) and log the error (e.g., using the logging
module with logging.exception or logging.error plus traceback) so failures
loading cuda.tile are visible; keep the existing print of _ct.__version__ when
import succeeds and reference the same symbols (_ct, __version__, cuda.tile)
when implementing the logging.
- Around line 141-167: Replace the local timing helpers _profiler_time_us and
_wallclock_time_us with the repository utility
flashinfer.testing.bench_gpu_time(): call bench_gpu_time(fn, ...) for the
profiler-style measurement using its CUPTI timing with auto-fallback to CUDA
events, and call bench_gpu_time(fn, ...) in the wall-clock/dispatch mode for
Python dispatch overhead comparisons; update any callers to use bench_gpu_time
instead of these two functions so timing is consistent with repo patterns.