tjo UddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlmZddlmZmZddlmZmZddlmZmZmZddlmZddl m!Z!ddl"Z#ddl$m%Z%dd l&m'Z'dd l(m)Z)ed Z*ej+e,Z-ej+d Z.ej/Z0d Z1dZ2dZ3dZ4dZ5dZ6da7ede8d<da9dZ:eGddZ;eGddZ<e;Z=e<a>ej?ej?ej?ej?dddddej?d Z@ddddddddddddddddddddddddddddddddddddddddddddddddddddddd6deAdzdeAdzd eAdzd!eAdzd"eAdzd#eAdzd$eAdzd%eAdzd&eAdzd'eAdzd(eAdzd)eAdzd*eBd+eBd,eBd-eBd.eBd/eBd0eBd1eBd2eBd3eBd4eBd5eBd6eBd7eBd8eBd9eBd:eBd;eBdeBd?eBd@eBdAeBdBeBdCeBdDeBdEeAdzdFeCeDeAeBzfdzdGeBdHeBdIeBdJeBdKeBdLeBdMeBdNeBdOeBdPeBdQeBdReBdSeBdTdfndUZEdTeFejGfdVZHddWZI d ddXZJdTejGfdYZKdZZLd[ZMd\d]Ne jOeLe jOeMgzd^zZPdd_ZQd`ZRdaZSddbZTddcZUddeDdTeDfdeZVejWdfZXdgZYdheDdTeeDdzfdiZZddjZ[dTeBfdkZ\ejWdleDdme]eDdnfdTeDfdoZ^dleDdTeDfdpZ_Gdqdrej`ZadsZbebZcddtZde!ZeduZfdvZgddwZhddxZidyZjddzZkddd{ZlGd|dejmZndd}Zoejpdd~ZqddTeBfdZr ddTeBfdZsejtdfdZuGddee*ZveewaxeCeDewfe8d<dewdTdfdZydTewdzfdZzddfdeDdeDdegeDe{zdzfde%dzdTdf dZ|eCfdddddddeDdegeCeDefe]eDeAfzfdegeDe{zdzfdeBdeBdeBde%dzdTdfdZ}eCfddddddeDdegeCeDefe]eDeAfzfdegeDe{zdzfdeBdeBdeBdTdfdZ~ddl$Z#ddl&Z#ddlmZddlZ#dS)N) defaultdict)CallableSequence) dataclassfield)AnyGenericOptional) ParamSpec)WeakSet) CompileId)log_trace_structured_event)CapturedTraceback_Pz torch.__trace TORCH_LOGSTORCH_LOGS_OUTTORCH_LOGS_FORMATTORCH_LOGS_TRACE_ID_FILTER TORCH_TRACE TORCH_DTRACELazyTraceHandlerLOG_TRACE_HANDLERFdedicated_log_torch_trace_ceZdZUeeZeeeefed<ee Z e eed<ee Z e eed<ee Z e eed<ee Z e eed<eeZeeefed<ee Ze eed<eeZeeejfed <d Zd Zd eeezd dfdZ ddZddZddZd e efdZdZdZdZdS) LogRegistrydefault_factorylog_alias_to_log_qnamesartifact_log_qnameschild_log_qnamesartifact_namesvisible_artifactsartifact_descriptionsoff_by_default_artifact_namesartifact_log_formattersc||jvSNr!selfnames V/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/torch/_logging/_internal.py is_artifactzLogRegistry.is_artifactft***c||jvSr')r)r*aliass r,is_logzLogRegistry.is_logis444r/ log_qnamesreturnNcJt|tr|g}||j|<dSr') isinstancestrr)r*r1r3s r, register_logzLogRegistry.register_logms. j# & & &$J.8$U+++r/c|j||r|j|||j|<|r|j||t j||j|<dSdSr')r!addr"r#r$logging Formatterr%)r*r+ descriptionvisibleoff_by_default log_formats r,register_artifact_namez"LogRegistry.register_artifact_namess %%%  -  " & &t , , ,+6"4(  9  . 2 24 8 8 8  !181B:1N1ND ( . . . " !r/c:|j|dSr')rr:)r*artifact_log_qnames r,register_artifact_logz!LogRegistry.register_artifact_logs   $$%788888r/c:|j|dSr')r r:)r* log_qnames r,register_child_logzLogRegistry.register_child_logs !!),,,,,r/cttj|jSr')set itertoolschain from_iterablervaluesr*s r,get_log_qnameszLogRegistry.get_log_qnamess/9?001M1T1T1V1VWWXXXr/c*t|jSr')rIrrNs r,get_artifact_log_qnamesz#LogRegistry.get_artifact_log_qnamess4+,,,r/c*t|jSr')rIr rNs r,get_child_log_qnamesz LogRegistry.get_child_log_qnamess4()))r/c||jvSr')r$)r*artifact_qnames r,is_off_by_defaultzLogRegistry.is_off_by_defaults!CCCr/r4N)__name__ __module__ __qualname__rdictrr7list__annotations__rIrr r!r"r#r$r%r;r<r-r2r8rArDrGrOrQrSrVr/r,rr@s4 5:E$4O4O4OT#tCy.1OOO %*E#$>$>$>S>>> "'s!;!;!;c#h;;; %uS999NCH999#(%"<"<"<s3x<<<-2E$,G,G,G4S>GGG /4eC.H.H.H!3s8HHH=BERV`_ An artifact is a particular type of log message. Each artifact is assigned to a parent component. A component can emit many different kinds of artifacts. In general, an artifact is emitted if either its corresponding setting in the argument list below is turned on or if its parent component is set to a log level less than or equal to the log level of the artifact. Keyword args: all (:class:`Optional[int]`): The default log level for all components. Default: ``logging.WARN`` dynamo (:class:`Optional[int]`): The log level for the TorchDynamo component. Default: ``logging.WARN`` aot (:class:`Optional[int]`): The log level for the AOTAutograd component. Default: ``logging.WARN`` autograd (:class:`Optional[int]`): The log level for autograd. Default: ``logging.WARN`` inductor (:class:`Optional[int]`): The log level for the TorchInductor component. Default: ``logging.WARN`` dynamic (:class:`Optional[int]`): The log level for dynamic shapes. Default: ``logging.WARN`` distributed (:class:`Optional[int]`): Whether to log c10d communication operations and other debug info from PyTorch Distributed components. Default: ``logging.WARN`` c10d (:class:`Optional[int]`): Whether to log c10d communication operations related debug info in PyTorch Distributed components. Default: ``logging.WARN`` ddp (:class:`Optional[int]`): Whether to log debug info related to ``DistributedDataParallel``(DDP) from PyTorch Distributed components. Default: ``logging.WARN`` fsdp (:class:`Optional[int]`): Whether to log debug info related to ``FullyShardedDataParallel``(FSDP) in PyTorch Distributed components. Default: ``logging.WARN`` dtensor (:class:`Optional[int]`): Whether to log debug info related to ``DTensor``(DTensor) in PyTorch Distributed components. Default: ``logging.WARN`` onnx (:class:`Optional[int]`): The log level for the ONNX exporter component. Default: ``logging.WARN`` bytecode (:class:`bool`): Whether to emit the original and generated bytecode from TorchDynamo. Default: ``False`` aot_graphs (:class:`bool`): Whether to emit the graphs generated by AOTAutograd. Default: ``False`` aot_joint_graph (:class:`bool`): Whether to emit the joint forward-backward graph generated by AOTAutograd. Default: ``False`` ddp_graphs (:class:`bool`): Whether to emit graphs generated by DDPOptimizer. Default: ``False`` graph (:class:`bool`): Whether to emit the graph captured by TorchDynamo in tabular format. Default: ``False`` graph_code (:class:`bool`): Whether to emit the python source of the graph captured by TorchDynamo. Default: ``False`` graph_code_verbose (:class:`bool`): Whether to emit verbose/intermediate FX pass logs for graph code. Default: ``False`` graph_breaks (:class:`bool`): Whether to emit the graph breaks encountered by TorchDynamo. Default: ``False`` side_effects (:class:`bool`): Whether to emit side effects (mutations, hooks, etc.) that TorchDynamo codegenerates in the output graph. Default: ``False`` graph_sizes (:class:`bool`): Whether to emit tensor sizes of the graph captured by TorchDynamo. Default: ``False`` guards (:class:`bool`): Whether to emit the guards generated by TorchDynamo for each compiled function. Default: ``False`` recompiles (:class:`bool`): Whether to emit a guard failure reason and message every time TorchDynamo recompiles a function. Default: ``False`` recompiles_verbose (:class:`bool`): Whether to emit all guard failure reasons when TorchDynamo recompiles a function, even those that are not actually run. Default: ``False`` trace_source (:class:`bool`): Whether to emit when TorchDynamo begins tracing a new line. Default: ``False`` trace_call (:class:`bool`): Whether to emit detailed line location when TorchDynamo creates an FX node corresponding to function call. Python 3.11+ only. Default: ``False`` trace_bytecode (:class:`bool`): Whether to emit bytecode instructions and traced stack state as TorchDynamo traces bytecode. Default: ``False`` output_code (:class:`bool`): Whether to emit the TorchInductor output code on a per-graph basis. Default: ``False`` kernel_code (:class:`bool`): Whether to emit the TorchInductor output code on a per-kernel basis. Default: ``False`` schedule (:class:`bool`): Whether to emit the TorchInductor schedule. Default: ``False`` perf_hints (:class:`bool`): Whether to emit the TorchInductor perf hints. Default: ``False`` pre_grad_graphs (:class:`bool`): Whether to emit the graphs before inductor grad passes. Default: ``False`` post_grad_graphs (:class:`bool`): Whether to emit the graphs generated by after post grad passes. Default: ``False`` ir_pre_fusion (:class:`bool`): Whether to emit the graphs before inductor fusion passes. Default: ``False`` ir_post_fusion (:class:`bool`): Whether to emit the graphs after inductor fusion passes. Default: ``False`` onnx_diagnostics (:class:`bool`): Whether to emit the ONNX exporter diagnostics in logging. Default: ``False`` fusion (:class:`bool`): Whether to emit detailed Inductor fusion decisions. Default: ``False`` overlap (:class:`bool`): Whether to emit detailed Inductor compute/comm overlap decisions. Default: ``False`` sym_node (:class:`bool`): Whether to emit debug info for various SymNode operations. Default: ``False`` export (:class:`Optional[int]`): The log level for export. Default: ``logging.WARN`` benchmarking (:class:`bool`): Whether to emit detailed Inductor benchmarking information. Default: ``False`` modules (dict): This argument provides an alternate way to specify the above log component and artifact settings, in the format of a keyword args dictionary given as a single argument. There are two cases where this is useful (1) if a new log component or artifact has been registered but a keyword argument for it has not been added to this function and (2) if the log level for an unregistered module needs to be set. This can be done by providing the fully-qualified module name as the key, with the log level as the value. Default: ``None`` cudagraph_static_inputs (:class:`bool`): Whether to emit debug info for cudagraph static input detection. Default: ``False`` autotuning (:class:`bool`): Autotuning choice logs, such as kernel source, perf, and tuning parameters. Default: ``False`` incremental (:class:`bool`): Incremental autotuning logs. Default: ``False`` graph_region_expansion (:class:`bool`): Whether to emit the detailed steps of the duplicate graph region tracker expansion algorithm. Default: ``False`` inductor_metrics (:class:`bool`): Whether to estimate the runtimes of the nodes in a graph and log them to the metrics table. Default: ``False`` hierarchical_compile (:class:`bool`): Whether to emit debug info for hierarchical compilation. Default: ``False`` caching (:class:`bool`): Whether to emit detailed Inductor caching information. Default: ``False`` Example:: >>> # xdoctest: +SKIP >>> import logging # The following changes the "dynamo" component to emit DEBUG-level # logs, and to emit "graph_code" artifacts. >>> torch._logging.set_logs(dynamo=logging.DEBUG, graph_code=True) # The following enables the logs for a different module >>> torch._logging.set_logs(modules={"unregistered.module.name": logging.DEBUG}) zQUsing TORCH_LOGS environment variable for log settings, ignoring call to set_logsNr4c :tj|D]\}}| t|rGt |t std|d||rt |jt |s|tj vr|tj vr?td|d|dddtj Dttj|||t%|rt'|p|f}|D]}t)|st||nt|ttj|||td|t/dS) Nz!Expected bool to enable artifact z , received zUnrecognized log level for log z: z, valid level values are: ,c,g|]}t|Sr^r7).0ks r, z/set_logs.._set_logs..s)O)O)OQ#a&&)O)O)Or/z6Unrecognized log or artifact name passed to set_logs: )rJrKrk log_registryr-r6bool ValueError log_staterdr2r r; _levelToNamejoinrirget_is_valid_module_get_module_and_submodules_has_registered_parentr8rG _init_logs)kwargsr1val found_modules module_namers r, _set_logszset_logs.._set_logssR#/&,,..'--//JJ& & JE3{''.." !#t,,$SESScSS5--e444$$U++ u 8U/U/Ug222$S%SS3SS #)O)O':N)O)O)O P PSS $$ 8<>E$11+{KKKK$77 DDD(($<@@'  !TUTT  r/torchrorprzrqrxrrrrsr{r|r}rrr~rrrrtrurrvrwrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrWr^) LOG_ENV_VARosenvironlogwarningrrn)7ryrorprzrxrqr{r|r}rrr~rrrrrsrrrrtrurrvrwrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrs7 ` r,set_logsrs?rbj   _     OOmG))))))VI666c6v6 C6 6  6  66:6(6:6 K6T6 C6T66 e!6":#6$.-%6&"\'6("\)6* K+6,v-6.:/60.-162"\364:566&~768 K96: K;6<=6>:?6@(A6B*)C6D$mE6F&~G6HTI6J*)K6LvM6NO6PQ6RvS6T:U6V,+W6X#<";Y6Z!8 7[6\"\]6^:_6` Ka6b 65c6d*)e6f21g6h21i6jk6666r/cHdtDS)z3 Returns: a list of all registered loggers c6g|]}tj|Sr^)r; getLogger)rqnames r,rzget_loggers..^s# P P PG e $ $ P P Pr/)rrOr^r/r, get_loggersrZs% Q P,2M2M2O2O P P PPr/c<t||dS)z Enables a log to be controlled by the env var and user API with the setting_name Args: setting_name: the shorthand name used in the env var and user API log_name: the log name that the setting_name is associated with N)rr8) setting_namelog_names r,r8r8as lH55555r/cBt|||||dS)a Enables an artifact to be controlled by the env var and user API with name Args: setting_name: the shorthand name used in the env var and user API description: A description of what this outputs visible: Whether it gets suggested to users by default off_by_default: whether this artifact should be logged when the ancestor loggers are enabled at level DEBUG N)rrA)rr=r>r?r@s r,register_artifactrks1''k7NJr/c|tjvr0tdt|dt|d|d|z}t j|}||_t|t||S)NzArtifact name: z. not registered,please call register_artifact(z") in torch._logging.registrations.z.__) rr!rreprr;rrcrDconfigure_artifact_log) module_qnamercrrs r,getArtifactLoggerr|sL777 ed=11 e e-1--@-@ e e e    000 0E  E " "C%C&&u---3 Jr/+-(|z?)ct|jrd|_t|jr(|tjd|_dSdSNFT) rrVrc propagaterrfsetLevelr;DEBUG)rs r,rrsh%%c&788 $$S%677 W]### r/c*tjdS)Nz$((\+|-)?[\w\.]+,\s*)*(\+|-)?[\w\.]+?)recompiler^r/r,_gen_settings_regexrs := > >>r/cHtjt|duSr')r fullmatchr)settingss r,_validate_settingsrs <+--x 8 8 DDr/c6d d|r tj}n tj}|rd}nd}dgttjztfd|Dz}dd|z}d }d |d |d |d }|S)Nct||kr"tdt|d||d|t|z zzS)Nzstring length z exceeds max  )lenAssertionError)slengths r,pad_tozhelp_message..pad_tosP q66F?? !O#a&&!O!Ov!O!OPP P3&3q66/***r/zAll registered namesz?Visible registered names (use TORCH_LOGS='+help' for full list)rycPg|]"}|dtj|#S) )rr#)rr+rs r,rz help_message..sG   6$<<MM<#Ed#KMM   r/z z a@ Examples: TORCH_LOGS="+dynamo,aot" will set the log level of TorchDynamo to logging.DEBUG and AOT to logging.INFO TORCH_LOGS="-dynamo,+inductor" will set the log level of TorchDynamo to logging.ERROR and TorchInductor to logging.DEBUG TORCH_LOGS="aot_graphs" will enable the aot_graphs artifact TORCH_LOGS="+dynamo,schedule" will enable set the log level of TorchDynamo to logging.DEBUG and enable the schedule artifact TORCH_LOGS="+some.random.module,schedule" will set the log level of some.random.module to logging.DEBUG and enable the schedule artifact TORCH_LOGS="+torch._functorch._aot_autograd" will set the log level of torch._functorch._aot_autograd and all its submodules to logging.DEBUG (directory-based logging) TORCH_LOGS_FORMAT="%(levelname)s: %(message)s" or any provided format string will set the output format Valid keys are "levelname", "message", "pathname", "levelno", "lineno", "filename" and "name". TORCH_LOGS_OUT=/tmp/output.txt will output the logs to /tmp/output.txt as well. This is useful when the output is long. z TORCH_LOGS Info z  )r)rr!r"sortedrkeysr)verboseprinted_artifactsheadinglines setting_infoexamplesmsgrs @r, help_messagers ++++ ;(7(:T(S  5::<< = = >     -       &++e,,,LH8            C Jr/cdgttjzttjz}dt |}d|d|d}|S)Nryz, z Invalid log settings: z, must be a comma separated list of fully qualified module names, registered log names or registered artifact names. For more info on various settings, try TORCH_LOGS="help" Valid settings: r)r\rrrr!rr)rrvalid_settingsrs r,_invalid_settings_err_msgrs  |388:: ; ; < |* + + , YYvn5566N        C Jr/ env_var_strcdtjdk}dtdtfd}|r ||}|S)ae When we setup logging config as guide: https://docs.pytorch.org/docs/stable/logging.html Such as: TORCH_LOGS="+schedule,+inductor,+output_code" On Linux, it shows as: declare -x SSH_TTY="/dev/pts/0" declare -x TERM="xterm" declare -x TORCH_LOGS="+schedule,+inductor,+output_code" declare -x USER="xu" On Windows, it shows as: TORCHINDUCTOR_WINDOWS_TESTS=1 TORCH_LOGS="+schedule,+inductor,+output_code" UCRTVersion=10.0.22000.0 For Linux, it shows quotes by default, And Windows is not shows quotes. Besides that, Windows would auto assemble quotes when env var processing. On Linux, we will get variable: "+schedule,+inductor,+output_code" On Windows, we will get variable: '"+schedule,+inductor,+output_code"' So, we need remove the outer quotes for Windows. win32rr4ct|dkr:|ddkr |ddks|ddkr|ddkr |ddS|S)Nr"')r)rs r,remove_outer_quotesz?process_env_var_string_for_windows..remove_outer_quotessT q66Q;; qTS[[QrUc\\qts{{qu||QrT7Nr/)sysplatformr7)r _IS_WINDOWSrs r,"process_env_var_string_for_windowsr sR0,')Kss7))+66 r/c t|}|dkriS|dkrttd|dkrttdt|stt |t jdd|}|d}d }t}|D]:}||\}}|d krd }t |r:|td tj |}| ||mt|r||t!|rtt#|p|f}|D]]}t%|st||nt|| ||^ tt ||S) NhelpF)rz+helpTz\s+rc|td}|td}|dtkr tj}n*|dtkr tj}n tj}||fS)Nr r)replaceINCR_VERBOSITY_CHARDECR_VERBOSITY_CHARr;rERRORINFO)r+ clean_namelevels r,get_name_level_pairz0_parse_log_settings..get_name_level_pair1sp\\"5r:: ''(;R@@ 7) ) )MEE !W+ + +MEELE5  r/ryrz#level must not be None for log name)r rrrrrsubsplitr`rr2rrrir-rdrrrr8rG) r log_namesrrr+rr3rrs r,_parse_log_settingsr s+1(;;H2~~ 6e444555 W  d333444 h ' '>28<<===vfb(++Hs##I ! ! ! IBB))$// e 5==D   t $ $ B}$%JKKK%=dCJ  U 3 3 3 3  % %d + + B  % %d + + + + d # # B6t<<GM, 9 9 -k::A --k;GGGG 33K@@@$$[%8888  96x@@AA A r/cHtj|}|duSr') importlibutil find_spec)rspecs r,rr\s" > # #E * *D t r/rc tj|}|dS|g}|j`tj|}t |drz,_get_module_and_submodules..zs$r/)pathprefixonerror) rrrsubmodule_search_locations import_modulehasattrpkgutil walk_packagesr!append)rrrpackageimportermodnameispkgs r,rras > # #E * *D |tgG &2)%00 7J ' ' (,3,A%s{&--- ( (('5 w'''' Nr/cvtjtd}|t |adSdSr')rrrrrr) log_settings r,_update_log_state_from_envr5s6*..d33K' 44 r/ctj|}t}|jr|j|vrdS|j}|jdS)NTF)r;rrrOparentr+)rFcur_logregistered_log_qnamess r,rrs[ **G(7799 .! <0 0 04. .! 5r/abs_pathsys_path.ctj|}|D]8} ||}t |cS#t $rY5wxYwt |S)a The string manipulation here is fairly expensive and we expect very high cache hit rates. Because `sys.path` changes very infrequently it's most performant to convert it into a tuple of strings and use that for the cache key because python has dedicated fast paths for list to tuple conversion and tuple hashing. (Empirically, a single top-level cache is about 2x faster than trying to cache individual parts.) )pathlibPathresolve relative_tor7r)r:r;abs_path_resolvedr&rel_paths r,_make_module_path_relativerCs X..6688!! !(44T::Hx==     H   ! !!sA AAcPt|ttjS)z Given an absolute filepath corresponding to a Python module which was loaded via normal import mechanisms using sys.path, convert it into a relative path relative to one of the Python search paths. )rCtuplerr&)r:s r,make_module_path_relativerFs &hch @ @@r/cLeZdZddddedeedzddffdZdZxZS) TorchLogsFormatterFN)tracetrace_id_filterrIrJr4cdt||_||_dSr')super__init__ _is_trace_trace_id_filter)r*rIrJ __class__s r,rMzTorchLogsFormatter.__init__s0  /r/c ttj|jdd}|7tj|d}|||S||_ | |d|_ |j }|j r;ddl m}|jp|dk}|r&|js||j |_|jr|dddkr|dz}||jz}|jr0|dddkr|dz}|||jz}d|_|jsBt-jr/t-jrd t-jd |_d|_|js1t6jjx} d |d |_d ddddd}||j|j} d|_ | d|d |_ tC|j"} |j#r"|j$|j#vrdS|j| |j dtK|j&dzdd|j'd| d|j(d |j|j  |jr|dkrtSd| dtUj+|j,tZ} |j.:| d/d|j.0dDz } | S|0d} d/ fd| DS)Nrcz %m%d %H:%M:%Sr)configrtrrr z[rankz]:z []VIWEC)rrWARNINGrCRITICALz [__r"i06dr:z%expected empty string for trace, got )defaultc3 K|] }d|V dS)z Nr^)rls r, z,TorchLogsFormatter.format.. s(LLAZAZZLLLLLLr/c3&K|] }d|V dS)rNr^)rr_r's r,r`z,TorchLogsFormatter.format..s-<<____<<<<< >QUVV  $!-!E!I!It"" "-)00888**,,AA N ? L , , , , , , & Q->2Q ! LL&*&:&:6?&K&KFO ? $v~~HFO#A   8v~~HD$$V%6777A~ <$"3"5"5 <$:M:O:O < ;  ; ; ;F  ."]9JJLLL.(---FN   (++F,NOO "  $$;=$;$;$;F !,V_==  ! $$&&d.CCC2  G* Gfn G Gs6 =Bww$%RQ%R%RSSSGGDJvEEEGGA~)RWWLL1E1Ed1K1KLLLLLLHGGDMME99<<<z%_default_formatter..s>  ::<< r/r r)rJ)shortbasic) rrrLOG_FORMAT_ENV_VARLOG_TRACE_ID_FILTERrrHr; BASIC_FORMATr<)fmtrJs r,_default_formatterrs *..+T 2 2CJNN#6;;AA#FFO  {!/BBBB $ $ $&C %%%r/ct|}|t|tj||dSr')_track_handler setFormatterDEFAULT_FORMATTERrr;r addHandler)create_handler_fnr debug_handlers r,_setup_handlersr$s\"#4#4#6#677M01117=)))NN=!!!!!r/c:t||Sr')handlersr:handlers r,rr0s LL Nr/c|tvSr')rrs r,_is_torch_handlerr5s h r/c\d|jD}|D]}||dS)Nc0g|]}t||Sr^)r)rrs r,rz#_clear_handlers..;s&SSSW8I'8R8RSSSSr/)r removeHandler)r to_removers r,_clear_handlersr:sGSS SSSI## '""""##r/ctD]K}tj|}|tjd|_t|Ltj t t D]<}tj|}|tj d|_=dt_ttdSr)rrOr;rrrYrrrJrKrQrSNOTSET trace_log)rFrrCs r, _reset_logsr@s!0022  ** W_%%% (o,,.. 0Q0Q0S0S 233 W^$$$ IIr/ctSr'rr^r/r,_get_log_staterTs r/c |adSr'r)states r,_set_log_staterXs IIIr/ctttjt d}||t D]<}|dkr tj |}| tj =t D].\}}tj |}| |/t D]E}tj |}ttj|tfd|Ft D]%}tj |}t#|&tjt$d}|Rtjdddkr.ddlmcm}tj|jd}tjt2dx}rda|}t6t9|at: tjd t:_tAt6} | !tEd t:#| dS) Nrc,tjSr')r; FileHandler) log_file_namesr,r%z_init_logs..s+M::r/TORCH_COMPILE_DEBUG01rtlparseTc"|tjkSr')rr)rs r,r%z_init_logs..s 5IO+Cr/)rI)$rr5rrrLOG_OUT_ENV_VARrrOr;rrrrrlr StreamHandlerrQr TRACE_ENV_VARtorch._dynamo.config_dynamorRr&rdebug_dir_rootDTRACE_ENV_VARGET_DTRACE_STRUCTUREDrrrr isEnabledForrrrHr) routrFrrrCtrace_dir_name dynamo_configdtrace_dir_nametrace_log_handlers ` r,rr]sMMM   *..$ / /C  "0022%%      ** W^$$$$&99;; 5 ** U"0022    **  !     $ ::::   +BBDD$$ 233s####Z^^M488N"*..1F"L"LPS"S"S444444444m&BINN*..>>>) $( ,^<<w}%%%DCI&'899""#5D#A#A#ABBB *+++++r/cXeZdZdZdedzddfdZdddeddfd Zd d Zd fd Z xZ S) rzRLike FileHandler, but the file is allocated lazily only upon the first log messageroot_dirNr4c||_tj|d|_d|_d|_t|_d|_ dS)NF) rr;HandlerrMstream_pid _stream_pathopen _builtin_open_pending_log_version)r*rs r,rMzLazyTraceHandler.__init__sM!   &&& $ (,!$)!!!r/Tflushrc|jr|j} |r|d|_d|_d|_d|_|r&t |dr|dS|sktj| |dS#t$r!}|j tj krYd}~dSd}~wwxYwdS#d|_d|_d|_d|_|r%t |dr|w|sitj| |w#t$r }|j tj krYd}~wd}~wwxYwwxYwdS)NFclose) rrrrrr+rrfilenoOSErrorerrnoEBADF)r*rrexcs r, _close_streamzLazyTraceHandler._close_streams ; "[F "!JJLLL"   $(!,1) "WVW55 "LLNNNNN "HV]]__---" """"9 33!433333" " " #   $(!,1) "WVW55 "LLNNNN "HV]]__---" """"9 33!43333" " " "sNCB** C4CCA,F EF  F&F<F FF c| ||jdup|jtjkt j|n$#t j|wxYw |dS#|wxYw)Nr) acquirerrrgetpidr;rrreleaserNs r,rzLazyTraceHandler.closes   2""d):)Vdi29;;>V"WWW %++D1111%++D11111 LLNNNNNDLLNNNNs9A0 B+0!BB++Ccrtj}|j!|j|kr|d|j*|jd}ddlm}t|dr/tj dt dntj dst d n}tj|st d |nBtj|tjst d |n||_|jtj|jd d}t)jr*t)jrdt)jd}t1jdt4|z|j\}}tj|d|_||_||_t d|jt;jd}| d|jd |_nt@!|dS|jr?tE#||jrd|_tIdSdSdS)NFrz/logsr git_versionMAST_HPC_JOB_NAMEz>LazyTraceHandler: disabled because not fbcode or conda on mastzpytorch/trace:enablezYLazyTraceHandler: disabled because justknobs_check('pytorch/trace:enable') returned Falsez4LazyTraceHandler: disabled because %s does not existz6LazyTraceHandler: disabled because %s is not writeableT)exist_okr rank__z.log)suffixr'dirzw+)modezLazyTraceHandler: logging to %sztorch._inductorztlparse raw data: %s)%rrrrrr torch.versionversionr+getenvrinfor_utils_internaljustknobs_checkr&existsaccessW_OKmakedirsrorprqrrtempfilemkstemp LOG_PREFIXfdopenrr;rrrrrLemit_log_torch_version) r*r current_pid TRACE_LOG_DIR torch_version ranksuffixfdr& inductor_logrPs r,rzLazyTraceHandler.emitsikk ; "tyK'?'?   U  + + + ; }$ ' 555555M=992 "566>HHX.>>?UVV2HHs 66 2HHN%="'::2HHP% %2DM}( DMD9999 $&&<4+>+@+@%>%>%>%>%>%>%>%>%>%r/cddl}ddlm}ddlm}|j|| dt ddfddd dS) Nr) is_fbcode)get_torch_source_version)pytorch_versioncommitossartifactc dddS)Nrrr+encodingr^r^r/r,r%z$_log_torch_version..2s_&IIr/cSr'r^) version_infosr,r%z$_log_torch_version..3s<r/TF) metadata_fn payload_fnsuppress_contextexpect_trace_id)rtorch._environmentrtorch._utils_internalr __version__trace_structured)rrrrs @r,rr%sLLL,,,,,,>>>>>>!,**,,9;;''L II'''' r/c |j|i|dS)a This function is similar to `logger.warning()`, but will emit the warning with the same message only once Note: The cache is for the function arguments, so 2 different callers using the same arguments will hit the cache. The assumption here is that all warning messages are unique across the code. If they aren't then need to switch to another type of cache that includes the caller frame information in the hashing function. N)r) logger_objargsrs r, warning_oncer9s"J''''''r/c$dt|vS)NzThe .grad attribute of a Tensorrrecategoryfilenamer~filelines r,safe_grad_filterr"Ds ,CLL @@r/c|tuSr') UserWarningrs r,user_warning_filterr%Hs ; &&r/cdS)NTr^)rrs r,r%r%OsDr/c#Ktjfd} |t_dVt_dS#t_wxYw)a A context manager that temporarily suppresses warnings, using public API: https://docs.python.org/3/library/warnings.html#warnings.showwarning. Useful to hide warnings without mutating warnings module state, see: https://github.com/pytorch/pytorch/issues/128427#issuecomment-2161496162. NOTE: Warnings issued under this context will still be cached in the __warningregistry__ and count towards the once/default rule. So you should NEVER use this on a user-land function. Filter must implement the showwarning API: def filter_fn(message, category, filename, lineno, file=None, line=None) -> bool: return True # show this warning entry c,|i|r |i|dSdSr'r^)rr filter_fnpriors r, _showwarningz#hide_warnings.._showwarning`s? 9d %f % % # E4 "6 " " " " " # #r/N)warnings showwarning)r)r+r*s` @r, hide_warningsr.Nsh  E######%+ $u$$$$s 6AcVeZdZdeeefdejdejddfdZdefdZ dS) LazyStringfuncrrr4Nc0||_||_||_dSr'r1rr)r*r1rrs r,rMzLazyString.__init__ls   r/c0|j|ji|jSr'r3rNs r,__str__zLazyString.__str__ssty$)3t{333r/) rXrYrZrrr7rrrMr5r^r/r,r0r0kspRW%.0gAC 4444444r/r0structured_logging_overhead time_spentcd}tjjx}|jj}|jj}|d|}|&t|}t|xx|z cc<dSdSNr) rrtrurv compile_idframe_idframe_compile_idr7r6)r7keyrr;r<s r,add_structured_logging_overheadr>|s CM0AACCCP&/#.?..,.. #hh#C(((J6(((((r/cd}tjjx}|jj}|jj}|d|}|t|SdSr9) rrtrurvr:r;r<r6r)r=rr;r<s r,get_structured_logging_overheadr@sl CM0AACCCP&/#.?..,.. *..s333tr/cdSr'r^r^r/r,r%r%Dr/r+r rr:c8tdfd||dS)Nr cdS)Nr r^)r r+sr,r%z+trace_structured_artifact..s   r/)rrr:)r)r+r rr:s`` r,trace_structured_artifactrEsK      r/cdSr'r^r^r/r,r%r%rBr/)rrrrecord_logging_overheadr:rrrrGcgd}||vrtd|dt|stdt|t|stdt|tjr`t j}i} || |<|stjr)tj rtj | d<tj j } |rQ| O|Mtjjt%jd | d <nL| r| jn|} | 3| j | j| d <| j | j| d <| j | j| d <| r | j| d<ddlm} | } | | | d<|}|t9|t:sUt9|t<r&ddd|Dzdz}nd}tAj!||d}tEj#d}|$|%d|&| d<t'd| |ddtQ|| |r,t j|z d z }tS|dSdSdS)!z metadata is an arbitrary JSON compatible struct, but it's expected to not be too long (e.g., less than 1MB) payload is an arbitrary string, which can be arbitrarily long (but expected to have newlines so no lines are too long) ) rankcompiled_autograd_idr;r<attemptseverity timestamprythread subgraph_namezname z is reserved and cannot be usedz(metadata_fn should be callable, but got z'payload_fn should be callable, but got rINr)skipstackrJr;r<rKr)$_get_regional_inductor_subgraph_namerOz[ z, c3>K|]}tj|VdSr')rr)ris r,r`z#trace_structured..s*0P0P1A0P0P0P0P0P0Pr/z ]ct|trt|Stdt |d)NzObject of type z is not JSON serializable)r6rIr\ TypeErrortype)objs r, json_defaultz&trace_structured..json_defaultsF%c3//-#'99,'Rd3iiRRRr/)r]indentF)usedforsecurityzutf-8 has_payloadr )rrr)extra stacklevelgeA)*rcallablerWrrtimetime_nsrorprqrrrrtrurv_logging structuredfrom_tracebackrextractsummaryr:rJr;r<rKtorch.fx.tracebackrRr6r7r\rrrhashlibmd5updateencode hexdigestdebugrr>)r+rrrrrGr:reserved_names start_timerrcidrRrOrrYhstructured_logging_overhead_ss r,rrsn&   N ~LTLLLMMM K   JtK7H7H J J    J    Hd:6F6F H H   AK\^^ $&"{}}t  8 "" 1t':'<'< 1!%v}3DDFFH 98#3 8J#(.";"J"J%-1555==??##w.6Eh)):?/;9<9Q56|/-0\z*+7585I129(0(8F9% O O O O O O@@BBM(*7'*,,  gs++ Rgt,,R#ejj0P0P0P0P0P&P&PPSXXGG#j,qQQQG E222A HHW^^G,, - - -$%KKMMF= ! 6g>>1     #4000 " K-1\^^j-HC,O ) +,I J J J J JCAKAK| K Kr/cdSr'r^r^r/r,r%r% rBr/rrrrGcBtrt||||||dSdS)zu For logging more detailed information used for debugging. This may result in the program becoming slow. rtN)rr)r+rrrrrGs r,dtrace_structuredrvsI   !-+$;         r/rW)FFN)Fr')NN) contextlibr functoolsrhimportlib.utilrrJrr;ros.pathr=r,rrrr`r, collectionsrcollections.abcrr dataclassesrrtypingrr r typing_extensionsr weakrefr torch._logging.structuredr torch._guardsr rrtorch.utils._tracebackrrrrXrrrYDEFAULT_LOG_LEVELrrrrrrrr]rrrr`rrrDEFAULT_LOGGINGr{rr[r7rr\Loggerrr8rrrrrescapeVERBOSITY_REGEXrrrrrr  lru_cacherrrr5rrErCrFr<rHrrrrrrrrrrrrrrcacherr"r%contextmanagerr.r0floatr6r>r@objectrErrvtorch.distributedr{rorgr^r/r,rsJ      ######........(((((((())))))))))'''''' ######<<<<<<444444Yt__g!! G o . . O "(2 268./666 )  VDVDVDVDVDVDVD VDr #$#$#$#$#$#$#$ #$L{}} HJJ l < L|   "!$$ !" ",0#&+$)#("!&!&oDDD tD $JD t D Dj D 4Z DDjDtD *D tD *D4ZD *DDD !D"#D$ %D&'D()D*+D,-D./D0 1D23D45D67D89D:;D<=D>?D@ADBCDDEDFGDHIDJKDLMDN ODPQDR $JSDT#sTz/ "T )UDVWDXYDZ[D\ $]D^"_D`aDbcDdeDf!gDhiDjkDlmDnoDp qDDDDN QT'.)QQQQ6666PT " gn     hh  -..  :M0N0NOPPQ      ???EEE<<<<~"$C$C$$$$N 888v chsmd.B@5555      ""c3h"C"""".AAAAAAX=X=X=X=X=*X=X=X=v & & &'&(("""" 799   #### ( O,O,O,O,O,ds%s%s%s%s%w,s%s%s%l( ((((AASWAAAA :>'' ''''  88%%%%8 4 4 4 4 4 4 4 41< E0B0BT#u*-BBB77$7777$     5AL#'  S6\D001D   *CG lK 5AL" $(#'lKlKlK lK"d38nuS#X>>? lK S6\D001 lKlKlK"lKD lK lKlKlKlKfCG  5AL"!$(    "d38nuS#X>>?  S6\D001    "      4 r/