sh+SSKrSSKrSSKJrJr SSKJr SSKJr SSK J r J r SSK J r JrJrJr SSKrSSKJrJr SSKJr \R.R1\S 5r\=(a \R6R95rS r\"S 5r\"S 5rS \ \ \ \4\4S\ \ \ \4\44Sjr "SS5r!"SS\!5r""SS\"5r#\(a\#"5r$g\""5r$g)N)cached_propertywraps)chain)median)AnyCallable) Concatenate ParamSpecSelfTypeVar)counters dynamo_timed)use_experimental_benchmarker benchmarkingiPTfnreturnc ^[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. selfargskwargsrc>URRSTR3n[SSU3==S- ss'[USS9 T"U/UQ70UD6sSSS5 $!,(df  g=f)N.inductorz benchmarking.T)log_pt2_compile_event) __class____name__r r)rrr fn_qual_namers x/Users/tiagomarins/Projetos/claudeai/copy_bank/venv/lib/python3.13/site-packages/torch/_inductor/runtime/benchmarking.pywrappertime_and_count..wrapper"sg..112!BKK=A }\N;<A< ,d Cd,T,V,D C Cs  A A,)rrrrrr)rr"s` r!time_and_countr$sF 2Y-c-!&&-AHH--- Nc \rSrSrS\SS4Sjr\S\S\S\4S\ \S4S \ \ \4S \S\ 4 S j5r \SS\S \/\4S \S\S\ 4 Sjj5r\S\S\S \S\ 4Sj5rSrg) Benchmarker,rrNcgN)rs r!__init__Benchmarker.__init__-s r%r.fn_args fn_kwargsrc ^^^Sn[TTR55HPn[U[R5(dM$UcUR nM5UR U:wdMG[ S5e Uc [ S5eUUU4SjnU[R "S5:XaUR"U40UD6$UR"U40UD6$)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. Arguments: - fn: The function to benchmark. - fn_args: The function's arguments. - fn_kwargs: The function's kwargs. Keyword Arguments: - **kwargs: The benchmarking implementation's kwargs. Returns: - The runtime of `fn(*fn_args, **fn_kwargs)`, in milliseconds. 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`! You should be calling `.benchmark_cpu` or `.benchmark_gpu` directly.c>T"T0TD6$r*r+)rr.r/sr!'Benchmarker.benchmark..YsB595r%cpu) rvalues isinstancetorchTensordevice ValueError benchmark_cpu benchmark_gpu)rrr.r/rinferred_device arg_or_kwarg _callables ``` r! benchmarkBenchmarker.benchmark0s6!'9+;+;+=>LlELL99&"."5"5$$7 y ?  "t 6 ell51 1%%i:6: :!!)6v66r%r?warmuprepcl^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. msrc>/n[R"5n[R"5nT"5 [R"5nURXC- [-5 XB- [-U:aU$M_r*)time perf_counterappendMILLISECONDS_PER_SECOND)rEtimings run_start_tstart_tend_tr?s r!run_for*Benchmarker.benchmark_cpu..run_foruslG++-K++- ))+3JJK(,CCrINr%)intlistfloatr)rr?rBrCrOs ` r!r;Benchmarker.benchmark_cpuas2(  U  gcl##r%rc[er*)NotImplementedError)rrrs r!r<Benchmarker.benchmark_gpus!!r%r+)d)r __module__ __qualname____firstlineno__r r,r$rrtupledictstrrSr@rQr;r<__static_attributes__r+r%r!r'r',s t  .7.7 S#X .7sCx.7S> .7  .7  .7.7`OR $ $'C0 $:= $IL $  $ $D"D"""""r%r'c h\rSrSr\S\S\S\44Sj5r\ S\S\/\4S\S\ 4Sj5r S r g ) TritonBenchmarkerrr.cPSSKJn U$![an[S5UeSnAff=f)z"Lazily import Triton's `do_bench`.r)do_benchzrequires TritonN)triton.testingre ImportErrorrV)rrees r!triton_do_bench!TritonBenchmarker.triton_do_benchs4 @ / @%&78a ? @s % %r?rc @[R"UR5Rn[ UR 55H nXC;dM X$ 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)inspect signatureri parametersrRkeys)rr?rdo_bench_paramskwargs r!r<TritonBenchmarker.benchmark_gpus$"++D,@,@ALL&++-(E+M) & '' O#ORWOOr%rbcf\rSrSr\S\S\4Sj5rS\S\S\\ \ RR\ RR44Sjr S\S\\ \ RR\ RR4S\4Sjr\SS\S \/\4S \S \S \S \S\S\4Sjj5rSrg)InductorBenchmarkerrrc[RR5n[RRU5nUR$)z7Get the L2 cache size, in bytes, of the current device.)r7cudacurrent_deviceget_device_properties L2_cache_size)rr9propss r!r|!InductorBenchmarker.L2_cache_sizes6**, 008"""r%itersc[U5Vs/sH=n[RRSS9[RRSS94PM? sn$s snf)z!Get `iters` pairs of CUDA events.T) enable_timing)ranger7ryEvent)rr_s r!get_event_pairs#InductorBenchmarker.get_event_pairss]5\  "   t 4   t 4 "    sAA event_pairsc l[UVVs/sHup#URU5PM snn5$s snnf)zIGet the minimum timing, in milliseconds, for a group of CUDA event pairs.)min elapsed_time)rr start_event end_events r!get_event_pairs_min_timing.InductorBenchmarker.get_event_pairs_min_timingsA/: .9*K((3.9    s0 r?estimation_itersmemory_warmup_itersbenchmark_itersmax_benchmark_durationrc [RR5 U"5 [RR5 [R"URS-[R SS9nUR 5 URU5nUH<upUR 5 U R5 U"5 U R5 M> [RR5 URU5n [[U[ X[-55S5n[U5Hn UR 5 M URU5nUH<upUR 5 U R5 U"5 U R5 M> [RR5 URU5n A[X5$)aBenchmark a GPU callable using a custom benchmarking implementation. Arguments: - _callable: The callable to benchmark. Keyword Arguments: - estimation_iters: Optionally, the number of iterations to run `_callable` during runtime estimation. - memory_warmup_iters: Optionally, the number of iterations to flush the L2 cache before starting benchmarking. - benchmark_iters: Optionally, the number of iterations to run `_callable` during the benchmarking. - max_benchmark_duration: Optionally, the maximum duration of the benchmarking, in milliseconds. An estimated duration is calculated based on the values of `memory_warmup_iters` and `benchmark_iters`, along with the estimated runtime of `_callable` and various other factors, and we then shrink `benchmark_iters` to fit in the alloted maximum duration. - **kwargs: Additional kwargs that may be passed to the fallback. Returns: - The minimum runtime of `_callable`, in milliseconds. ry)dtyper9r) r7ry synchronizeemptyr|rQzero_rrecordrmaxrr)rr?rrrrrbufferrrrestimated_timingrbenchmarked_timings r!r<!InductorBenchmarker.benchmark_gpusyB       T//14EIIfU **+;< &1 "K LLN    K     '2   ::;G %;%O!P QST  *+A LLN,**?; &1 "K LLN    K     '2   !<<[I #88r%r+N)rYrY)rrZr[r\rr rQr|rRr]r7ryrrrSrr$rrr<r`r+r%r!rvrvs##D#S##      eEJJ$$ejj&6&667 8      !%eEJJ,<,N>N,N&O!P    !"#&"&( M9M9BG$M9M9! M9  M9 !$ M9M9 M9M9r%rv)%rnrG functoolsrr itertoolsr statisticsrtypingrrtyping_extensionsr r r r r7torch._dynamo.utilsr rtorch._inductor.configr_logginggetArtifactLoggerrloggerry is_availablerJrrr$r'rbrv benchmarkerr+r%r!rs , CC 6?  ) )(N C >UZZ%<%<%>  cN CLS!V$a'( k#q&!1$%$Z"Z"z$O $ONm9+m9b: ?P?R r%