uki2UddlmZddlZddlmZddlZddlZddlZddl m Z ddl Z ddl Z ddlmZddlmZddlmZddlmZddlmcmZdd lmZdd lmZdd lmZdd lmZmZdd l m!Z!m"Z"ejFe$Gdde%Z&e jNe jPjRZ*ejVZ,ga-de.d<Gddej^Z0e0Z1d'dZ2GddZ3d(dZ4d'dZ5ejldGddZ7ejpe7ddejre7e7jtd e7jvd!d"#d)d$Zy)*) annotationsN)partial) TracebackType)core)source_info_util)traceback_util) tree_util) shard_map)_export)lax) NamedSharding PartitionSpec)Array ArrayLikeceZdZdZy) JaxValueErrorzEException raised for runtime errors detected within JAX computations.N)__name__ __module__ __qualname____doc__O/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/jax/_src/error_check.pyrr*sMrrz%list[tuple[str, TracebackType | str]] _error_listceZdZdZy) _ErrorStoragecd|_yN)refselfs r__init__z_ErrorStorage.__init__<s $DHrN)rrrr"rrrrr:s%rrc^tj}|jrtjt }nUt |t|j}tj|jtjt |}tj|t_y)a Initialize the error code ref in the current thread. The shape and size of the error code array depend on the mesh in the context. In single-device environments, the array is a scalar. In multi-device environments, its shape and size match those of the mesh. shardingN)mesh_libget_concrete_meshemptynpuint32 _NO_ERRORr P axis_namesr full axis_sizesrnew_ref_error_storager)mesh error_coder%s r_initialize_error_code_refr4Csu  # # %$ ZZIIi0JT1doo#67H  )J ||J/.rc&eZdZdZdZdZdZdZy)error_checking_contextaqRedefine the internal error state based on the mesh in the context. When using JAX in multi-device environments in explicit mode, error tracking needs to be properly aligned with the device mesh. This context manager ensures that the internal error state is correctly initialized based on the current mesh configuration. This context manager should be used when starting a multi-device computation, or when switching between different device meshes. On entering the context, it initializes a new error state based on the mesh in the context. On exiting the context, it restores the previous error state. old_refcd|_yrr7r s rr"zerror_checking_context.__init__ls DLrctj|_tj5t ddd|S#1swY|SxYwr)r1rr8r eval_contextr4r s r __enter__z error_checking_context.__enter__os;!%%DL   # "# K# Ks ?A c.|jt_yr)r8r1r)r!exc_type exc_value tracebacks r__exit__zerror_checking_context.__exit__usNrN)rrrr __slots__r"r<rArrrr6r6[s ) &rr6cddlm}tj9t j 5t dddtjJtjj}|J|j}t|tsJtj|}t|tsJt5t!j"t%t&}t&j)||fdddt j*tjj,}t j*|j,}t/d|j0Dr|j3}nt4j6j8|j:j<v}|r+t?j@dtB|j3}n|j:|j:k7r&tEd|j:d|j:dtGjFtI|j2d |j:|j0|j0 |}tjd }|jK||j#tLk(|} |jO| |}|tjd <y#1swYxYw#1swYxYw) a(Set the internal error state if any element of `pred` is `True`. This function is used inside JAX computations to detect runtime errors without immediately halting execution. When this function is traced (e.g., inside :func:`jax.jit`), the corresponding error message and its traceback are recorded. At execution time, if `pred` contains any `True` values, the error state is set, but execution continues without interruption. The recorded error can later be raised using :func:`raise_if_error`. If the error state has already been set, subsequent errors are ignored and will not override the existing error. For multi-device environments, in explicit mode, users must call :func:`error_checking_context` to initialize a new error tracking state that matches the device mesh. In auto mode, implicit cross-device communication may occur inside this function, which could impact performance. A warning is issued in such cases. When exporting a function with `jax.export`, error checking must be explicitly wrapped using :func:`wrap_for_export` before export and :func:`unwrap_from_import` after import. Args: pred: A JAX boolean array. If any element of `pred` is `True`, the internal error state will be set. msg: The corresponding error message to be raised later. rNc3$K|]}|du ywrr).0dims r zset_error_if..s22szWhen at least one mesh axis of `pred` is in auto mode, calling `set_error_if` will cause implicit communication between devices. To avoid this, consider converting the mesh axis in auto mode to explicit mode.zIThe error code state and the predicate must be on the same mesh, but got z and zm respectively. Please use `with error_checking_context()` to redefine the error code state based on the mesh.T)keepdims)r2in_specs out_specs.)( jax.numpynumpyr1rrr;r4rcurrentr@as_python_traceback isinstancerrfilter_traceback_error_list_lockr)r*lenrappendtypeofr%allspecanyr&AxisTypeAutor2 axis_typeswarningswarnRuntimeWarning ValueErrorr r logical_andr+where) predmsgjnpr@new_error_code out_sharding in_sharding has_auto_axesr3 should_updates r set_error_ifriysg:   # "#    )) )&&(22)   ++-) I} -- ---i8) I} -- -)YYs;/0NY'()^//099,#{{4099+ 2 1 122 88:D%%**k.>.>.I.IIMmm   XXZd   k.. . #((){/?/?.@A, ,  Y #''D )  ## %%  d!!#&*//* 90E"EtL-yy C*&.Si##))s K :K KK#ctjytjdj}t|tj r t d|tjtk(rytjtjjtjttjjtjd<t5t|\}}dddtt rt#d|}|t#}|j%|#1swYGxYw)a"Raise an exception if the internal error state is set. This function should be called after a computation completes to check for any errors that were marked during execution via `set_error_if()`. If an error exists, it raises a `JaxValueError` with the corresponding error message. This function should not be called inside a traced function (e.g., inside :func:`jax.jit`). Doing so will raise a `ValueError`. Raises: JaxValueError: If the internal error state is set. ValueError: If called within a traced JAX function. N.z`raise_if_error() should not be called within a traced context, such as within a jitted function.r$z( The original traceback is shown below: )r1rminrOrTracerr^r)r*r+r r.shaper%rQrstrrwith_traceback)r3rbr@excs rraise_if_errorrqs !!#&**,* DKK(  % 299Y'' HHii !!**.S - ,NC- 3  %9)E C I  C  Y ''--s + D>>ET)frozenc&eZdZUdZded<ded<y) _ErrorClassaA class to store error information for AOT compilation. This class is used internally by the wrapper functions `wrap_for_export` and `unwrap_from_import` to encapsulate error-related data within an exported function. Attributes: error_code (jax.Array): A JAX array representing the final error state of the function to be exported. This value is local to the wrapper function. error_list (list[tuple[str, str]]): A list of `(error_message, traceback)` pairs containing error messages and corresponding stack traces. This error list is local to the wrapper function, and does not contain pairs of error information from other functions. rr3zlist[tuple[str, str]] error_listN)rrrr__annotations__rrrrtrts ##rrt)r3)ru) data_fields meta_fields.cNtj|djdS)NF) ensure_asciiutf-8)jsondumpsencodexs rrs 15 A H H!rcJtj|jdS)Nr|)r}loadsdecoders rrrs$**QXXg->"?r)serialized_nameserialize_auxdatadeserialize_auxdatacdjtjtj|j dS)z+Convert a traceback to a string for export. )jointb_lib format_list extract_tbrstrip)r@s r_traceback_to_strrs2 ##F$5$5i$@A B I I$ OOrcfd}|S)aWrap a function with error checking to make it compatible with AOT mode. Error checking relies on global state, which cannot be serialized across processes. This wrapper ensures that the error state remains within the function scope, making it possible to export the function and later import in other processes. When the function is later imported, it must be wrapped with :func:`unwrap_from_import` to integrate the error checking mechanism of the imported function into the global error checking mechanism of the current process. This function should only be applied once to a function; wrapping the same function multiple times is unnecessary. ctj5tj}dddt t 5t gc}a |i|}tjdj}|t ca}dddtj5t_dddDcgc]\}}|t|f}}}t|fS#1swYxYw#1swYjxYw#1swYNxYwcc}}wN.) rr;r1rr4rQrrkrrt) argskwargsr8old_error_listoutr3new_error_listrbr@fs rinnerzwrap_for_export..inner3s    #""g# @$/!nk t v c!%%c*..0j%3K!k>@    #"n#CQ0>Y *+N  J7 77%##@@##s(C.inner^s$)&)C!,!7!79O9OJN %;f$%  ##C(JOObii **"))I..MM>F+BJOJ(Ns J%%s %C$$C-)r1rrr;r4rs` runwrap_from_importrNsV   # "#    )) )* ,3##s AA)returnNone)rbrnrarrr)r@rrrn)? __future__r dataclasses functoolsrr} threadingr@rtypesrr[rLr)jax._srcrrrr jax._src.mesh_srcr2r&r jax._src.exportr jax._src.laxr jax._src.sharding_implsr rr,jax._src.typingrrregister_exclusion__file__r^riinfor*maxr+RLockrQrrvlocalrr1r4r6rirq dataclassrtregister_dataclass"register_pytree_node_serializationrrrrrrrrrs\# %# #E,"!!(+NJN BHHRYY  # # #9??$57 27%IOO% 00&&