ȅiwEPSSKrSSKrSSKrSSKJr SSKJrJr SSKJr SSK J r SSK J r J r JrJr SSKJrJrJr SSKrSSKJs Jr SSKJs Jr SSKJrJr SS K J!r! \RDRG\$S 5r%\RL=(a \RNRQ5r&S r)\"S 5r*\"S 5r+S\S\ 4S\S\ 44Sjr,SSjr-S\\ \ \*4\+4S\\ \ \*4\+44Sjr."SS5r/"SS\/5r0"SS\05r1\&(a\1"5r2g\0"5r2g)N)Callable)cached_propertywraps)chain)median)Any ConcatenateOptionalUnion) ParamSpecSelfTypeVar)counters dynamo_timed) DebugMode benchmarkingiPTfn.returnc ^^^SSKJm TRRS:XaT$S[[ [ [ S4-[ -S[[ [ [ S4-[ -4UU4Sjjm[R"T5S[[S [[[4S[[ [ [ S4-[ -4UU4S jj5nU$) Nr)configms.rcB>[U[[45(a[U5"U4SjU55$TRR n[U[ 5(deUS:XaU(aSU- $S$US:XaSSKnUR5$[SU35e)Nc34># UH nT"U5v M g7fN).0valdistorts ^/home/james-whalen/.local/lib/python3.13/site-packages/torch/_inductor/runtime/benchmarking.py Cmay_distort_benchmarking_result..distort..(s7BSGCLLBsinverseg?grandomrzUnrecognized distort method ) isinstancelisttupletype test_configsdistort_benchmarking_resultfloatr& RuntimeError)rdistort_methodr&rr!s r"r!0may_distort_benchmarking_result..distort$s b4- ( (87B77 7,,HH"e$$$$ Y &!38 *s * x ' ==? "!=n=MNO Oargskwargsc$>T"U0UD6nT"U5$rr)r2r3rr!rs r"wrapper0may_distort_benchmarking_result..wrapper5s  r{r1) torch._inductorrr+r,r(r-r) functoolsrrdictstr)rr5rr!s` @@r"may_distort_benchmarking_resultr;s& 66"< P K%s + +e 3P euUCZ( (5 0PP"__RCy$(cN euUCZ( (5 0 Nr1cl[RRR(a [ S5eg)NaIn the deterministic mode of Inductor, we will avoid those benchmarkings that would cause non deterministic results. Only benchmarkings in the vetted scenarios are allowed. Example include autotuning for triton configs of pointwise kernels. When you see this exception, you can do one of the following two things: 1. if the benchmarking you are doing does not introduce any non-determinism, you can just add is_vetted_benchmarking=True to you benchmark_gpu call. That would solve the issue. 2. if the benchmarking you are doing indeed introduces non-determinism, you'll need to disable such feature in deterministic mode or find an alternative implementation that is deterministic. )torch _inductorr deterministicr.rr1r"may_ban_benchmarkingr@@s, ++   ,r1c ^[T5S[S[RS[RS[ 4U4Sjj5nU$)zWraps `fn` with `dynamo_timed` context, and increments the appropriate dynamo counters. It is expected that `fn` is a method of `Benchmarker` or one of its subclasses; typing limitations prevent us from declaring this directly. selfr2r3rc>URRSTR3n[SSU3==S- ss'[USS9 T"U/UQ70UD6sSSS5 $!,(df  g=f)N.inductorz benchmarking.F)log_pt2_compile_event) __class____name__rr)rBr2r3 fn_qual_namers r"r5time_and_count..wrapperWsg..112!BKK=A }\N;<A< ,e Dd,T,V,E D Ds  A A,)rrrr2r3r)rr5s` r"time_and_countrLOsF 2Y-c-!&&-AHH--- Nr1c8\rSrSrSrS\SS4SjrS\S\S\R4S jr \ SS\S \ S \4S\ \\S 4S\ \\\4S \ \\\R4S \S\4Sjj5r\ SS\S\ /\4S\S\S\4 Sjj5r\ S\S\S \S\4Sj5rSrg) Benchmarkerazc A device-agnostic benchmarking utility for measuring the runtime of inductor generated callables. rBrNcgrr)rBs r"__init__Benchmarker.__init__gs r1fn_args fn_kwargsc:Sn[XR55Hmn[R"U5HPn[ U[ R 5(dM$UcURnM5URU:wdMG[S5e Mo Uc [S5eU$)NzcCan't safely infer the device type of `fn` with multiple device types in `fn_args` and `fn_kwargs`!zCan't safely infer the device type of `fn` with no device types in `fn_args` or `fn_kwargs`. Use a direct benchmarking method instead e.g. `Benchmarker.benchmark_cpu` or `Benchmarker.benchmark_gpu`.) rvaluespytree tree_leavesr'r=Tensordevice ValueError)rBrSrTinferred_device arg_or_kwargarg_or_kwarg_leafs r" infer_deviceBenchmarker.infer_devicejs26!'+;+;+=>L&,%7%7 %E!!"3U\\BB"*&7&>&>O&--@$} &F?  "N  r1r.rZr3c :^^^SnUb.[U[5(a[R"U5OUnOATcTc [ S5eT=(d [ 5mT=(d 0mUR "T0TD6n[U[R5(deT=(d [ 5mT=(d 0m[T5S:Xa[T5S:XaTnOUUU4SjnURS[R5nURS[R5n [R"5 U[R"S5:XaUR"U4XS.UD6sSSS5 $UR"U4XS.UD6sSSS5 $!,(df  g=f) aBenchmark `fn(*fn_args, *fn_kwargs)` and return the runtime, in milliseconds (the actual runtime calculation is dictated by the benchmarking implementation, but may be one of [mean, median, minimum, etc.]). Functions as a convenience wrapper around device-specific implementations, like `benchmark_cpu` and `benchmark_gpu`. Raises `ValueError(...)` if we can't safely infer the device type of `fn`; for example, if multiple device types are found in `fn_args` and `fn_kwargs`, or if no device types are found. To bypass device inference, provide the device to the `device` parameter. WARNING: if `fn` mutates `fn_args` or `fn_kwargs`, benchmarking may fail unexpectedly. For example, if `fn` clears a mutable object, subsequent invocations of `fn` during benchmarking will fail. In such cases, `fn` should handle cloning its arguments internally. If device inference is required, `Benchmarker.infer_device` can be used prior to calling this method without any arguments for `fn_args` and `fn_kwargs`. Arguments: - fn: The function to benchmark. - fn_args: The function's arguments. - fn_kwargs: The function's kwargs. Keyword Arguments: - device: Which device to use for benchmarking. If not provided the device will be attempted to be inferred from `fn_args` and `fn_kwargs`. - **kwargs: The benchmarking implementation's kwargs. Returns: - The runtime of `fn(*fn_args, **fn_kwargs)`, in milliseconds. NzJ`fn_args` and `fn_kwargs` cannot both be None if `device` is not provided.rc>T"T0TD6$rr)rrSrTsr"'Benchmarker.benchmark..sG 9y 9r1warmuprepcpu)rerf)r'r:r=rZr[r)r_lenpopinductor_config inductor_default_autotune_warmupinductor_default_autotune_repr_benchmarking_inductor benchmark_cpu benchmark_gpu) rBrrSrTrZr3r\ _callablererfs ``` r" benchmarkBenchmarker.benchmarksXJ37  (263(?(? V$V 9#4 `(G!RI"//FIFO/5<<8888$UWO  w<1 Y1!4I9IHo&V&VWjj M MN - - /%,,u"55)))VFVvV0 / %%iRR6R 0 / /s5/F .F  Frprerfcl^S[S[[4U4SjjnU"U5 [U"U55$)aBenchmark the CPU callable, `_callable`, and return the median runtime, in milliseconds. Arguments: - _callable: The CPU callable to benchmark. Keyword Arguments: - warmup: Optionally, the duration, in milliseconds, to run `_callable` before benchmarking starts. - rep: Optionally, the duration, in milliseconds, to run `_callable` during benchmarking. Returns: - The median runtime of `_callable`, in milliseconds. rrc>/n[R"5n[R"5nT"5 [R"5nURXC- [-5 XB- [-U:aU$M_r)time perf_counterappendMILLISECONDS_PER_SECOND)rtimings run_start_tstart_tend_trps r"run_for*Benchmarker.benchmark_cpu..run_forslG++-K++- ))+3JJK(,CCrINr1)intr(r-r)rBrprerfr}s ` r"rnBenchmarker.benchmark_cpus2(  U  gcl##r1r2c[er)NotImplementedError)rBr2r3s r"roBenchmarker.benchmark_gpus!!r1r)NNN)d)rI __module__ __qualname____firstlineno____doc__r rQrr=rZr_rLrr r)r9r:r r-rqrrnro__static_attributes__rr1r"rNrNas[  t  Ssu||0.2.259 HSHS S#X HS%S/*HSDcN+ HS sELL012 HS  HS HSHSTOR $ $'C0 $:= $IL $  $ $D"D"""""r1rNc |\rSrSr\S\S\S\44Sj5r\ \ S S\S\/\4S\ S\S\ 4 S jj55r S rg ) TritonBenchmarkerrBr.cPSSKJn U$![an[S5UeSnAff=f)z"Lazily import Triton's `do_bench`.r)do_benchzrequires TritonN)triton.testingr ImportErrorr)rBres r"triton_do_bench!TritonBenchmarker.triton_do_benchs4 @ / @%&78a ? @s % %rpis_vetted_benchmarkingr3c bU(d [5 [R"UR5Rn[ UR 55H nXT;dM X5 M SU;aUR"U40UD6S$SU;aUR"U40UD6$UR"U40UDSS0D6$)aBenchmark the GPU callable, `_callable`, and return the runtime, in milliseconds. Arguments: - _callable: The GPU callable to benchmark. Keyword Arguments: - quantiles: Optionally, a tuple of floats denoting the requested quantiles. - return_mode: Optionally, the requested return mode. Currently, Triton's `do_bench` supports min, max, mean, and median return modes. - **kwargs: Additional kwargs passed to Triton's `do_bench`. Returns: - The runtime of `callable`, in milliseconds. If `kwargs["quantiles"]` is specified, this is the first requested quantile. Else, if `kwargs["return_mode"]` is specified, this is the requested return mode. Otherwise, this is the median. quantilesr return_moder)r@inspect signaturer parametersr(keys)rBrprr3do_bench_paramskwargs r"roTritonBenchmarker.benchmark_gpus2& "!++D,@,@ALL&++-(E+M) & '' Ir)rrrNF)rIrrrrr rrr(r)r=rrrr-rr;rLrrr:rYrrorrr1r"rr&sl#D#S##      eEJJ$$ejj&6&667 8      !%eEJJ,<,N>N,N&O!P    %!"#&"&( 26',ppBG$pp! p  p !$ pp5<<(4/p!%pp e p%pr1r)rN)3r8rrucollections.abcrrr itertoolsr statisticsrtypingrr r r typing_extensionsr r rr=torch._inductor.configr>rrjtorch.utils._pytreeutils_pytreerWtorch._dynamo.utilsrrtorch.utils._debug_moder_logginggetArtifactLoggerrIloggeruse_experimental_benchmarkerr is_availablerxrrr;r@rLrNrr benchmarkerrr1r"rs: $,4466 00$$6-  ) )(N C00NUZZ5L5L5N  cN CLc(:xS?QD  S!V$a'( k#q&!1$%$Q"Q"h.O .ObQ+Qj: ?P?R r1