Vpf)ddlmZddlmZmZmZddlZddlZddlZddl m Z ddl m Z ddl m Z ddl mZddl mZdd lmZmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZmZmZm Z ddl!Z"ej#e$cZ$Z% dIdJdZ&dZ'dKdZ(dddd dLd)Z)dMd-Z*dNd0Z+d1d2dOd;Z,dPd>Z-d?Z.d@Z/dQdFZ0e j1dGZ2dHe2_3e24ej5e j6e2e27e-e.ej8e2<e/ej9e2<ej5ee2ej:e2<ej;e2e0dS)R) annotations)IterableMappingSequenceN)Any)core)dispatch)dtypes)util)_check_shape_dtypecallback_batching_rule)ad)batching)mlir)jaxlib) xla_client)ir)Array ArrayLikeDimSizeDuckTypedArraycpunamestrfnrplatform api_versionintkwargsreturnNonec ,tj||||fi|S)aRegisters a foreign function target. Args: name: the name of the target. fn: a ``PyCapsule`` object containing the function pointer, or a ``dict`` where the keys are FFI stage names (e.g. `"execute"`) and the values are ``PyCapsule`` objects continaing a pointer to the handler for that stage. platform: the target platform. api_version: the XLA custom call API version to use. Supported versions are: 1 (default) for the typed FFI or 0 for the earlier "custom call" API. kwargs: any extra keyword arguments are passed directly to :func:`~jaxlib.xla_client.register_custom_call_target` for more advanced use cases. )rregister_custom_call_target)rrrrr s S/var/www/html/nettyfy-visnx/env/lib/python3.11/site-packages/jax/_src/extend/ffi.pyregister_ffi_targetr&(s.*  /b(K : :28 : ::ctjdtj}tjj}tj|_tjtj|f|_||d|dS)aWrap a ctypes function pointer in a PyCapsule. The primary use of this function, and the reason why it lives with in the ``jax.extend.ffi`` submodule, is to wrap function calls from external compiled libraries to be registered as XLA custom calls. Example usage:: import ctypes import jax from jax.lib import xla_client libfoo = ctypes.cdll.LoadLibrary('./foo.so') xla_client.register_custom_call_target( name="bar", fn=jax.extend.ffi.pycapsule(libfoo.bar), platform=PLATFORM, api_version=API_VERSION ) Args: funcptr: A function pointer loaded from a dynamic library using ``ctypes``. Returns: An opaque ``PyCapsule`` object wrapping ``funcptr``. Nr) ctypes CFUNCTYPE py_object pythonapi PyCapsule_Newrestypec_void_pc_char_pargtypes)funcptr destructorbuilders r% pycapsuler5As]6f&677*   *'$'/ov C' $ 1 . ..r'ctjtjtj}tj|dS)zIGet the path to the directory containing header files bundled with jaxlibinclude)ospathdirnameabspathr__file__join) jaxlib_dirs r% include_dirr?cs;wrwv??@@* j) , ,,r')operand_layoutsresult_layoutsbackend_configcall_target_namer@"Sequence[Sequence[DimSize]] | NonerArB!Mapping[str, ir.Attribute] | None lowering_argsmlir.LoweringRulec $d fd }|S) aBuild a lowering rule for an foreign function interface (FFI) target. By default, this lowering rule can use the input and output abstract values to compute the input and output types and shapes for the custom call, assuming row-major layouts. If keyword arguments are passed to the lowering rule, these are treated as attributes, and added to `backend_config`. Args: call_target_name: The name of the custom call target. operand_layouts: A sequence of layouts (dimension orders) for each operand. By default, the operands are assumed to be row-major. result_layouts: A sequence of layouts (dimension orders) for each result. By default, the results are assumed to be row-major. backend_config: Configuration data for the custom call. Any keyword arguments passed to the lowering rule will added to this dictionary. lowering_args: Any other arguments to :func:`mlir.custom_call` will also be passed through if provided as extra arguments to this function. ctxmlir.LoweringRuleContextoperandsir.Valueparamsrr!'Sequence[ir.Value | Sequence[ir.Value]]ct}|ddtpifid|D|d<d|vrd|jD|d<!t d|jD|d<!t d |jD|d <t jfd |i|jS) Nrc4i|]\}}|t|S) _ir_attribute).0kvs r% z3ffi_lowering.._lowering..s&NNNtq!q-"2"2NNNr'rB result_typesc6g|]}tj|SrR)raval_to_ir_typerTavals r% z3ffi_lowering.._lowering..s#UUUt 4T : :UUUr'c3$K|] }|jV dSNshaper[s r% z2ffi_lowering.._lowering..s$2W2W$4:2W2W2W2W2W2Wr'r@c3$K|] }|jV dSr_r`r[s r%rbz2ffi_lowering.._lowering..s$1W1W$*1W1W1W1W1W1Wr'rArK) dict setdefaultitems avals_out_default_layoutsavals_inr custom_callresults) rIrKrMr rBrCrFr@rAs r% _loweringzffi_lowering.._lowerings- F mQ'''# P PNNv||~~NNN P PF V##UUs}UUUf^"22W2W#,2W2W2W"W"Wf !11W1W1W1W1W!W!Wf   , J Jx J6 J J RRr')rIrJrKrLrMrr!rNrR)rCr@rArBrFrls````` r% ffi_loweringrmisK:SSSSSSSSSS r'shapesIterable[Sequence[DimSize]]list[list[DimSize]]cd|DS)Nc zg|]8}tttt|9SrR)listreversedrangelen)rTras r%r]z$_default_layouts..s6 @ @ @$xc%jj))** + + @ @ @r'rR)rns r%rhrhs @ @ @ @ @@r'obj ir.Attributecrt|trtj|St|t rtj|St|trtj |St|trtj |St|drtj|s#t!j|st%dtj|j}t|tjr tj||St|tjr tj ||St%dt1|)Ndtypez$Only scalar attributes are supportedzUnsupported attribute type: ) isinstancerr StringAttrgetboolBoolAttrrri64_attrfloat FloatAttrget_f64hasattrr is_python_scalarnpisscalar TypeErrordtype_to_ir_typerz IntegerType IntegerAttr FloatTypetype)rw mlir_types r%rSrSshS. =  S ! !!#t . ;??3  #s . =  #u . <   $ $$sG.  #C ( (>BK,<,<> < = ==%ci00I)R^,,. ^   3 / // Ir| , ,. \  i - --<c<<===r'F) vectorized target_nameresult_shape_dtypes)DuckTypedArray | Sequence[DuckTypedArray]argsrrr~Array | list[Array]ct|trd}|}nd}|f}tt|t d|D}t j||||d|}|r|S|dS)aCall a foreign function interface (FFI) target. Like :func:`~jax.pure_callback`, the behavior of ``ffi_call`` under :func:`~jax.vmap` depends on the value of ``vectorized``. When ``vectorized`` is ``True``, the FFI target is assumed to satisfy: ``ffi_call(xs) == jnp.stack([ffi_call(x) for x in xs])``. In other words, calling the FFI target with an extra leading dimension should return the same result as calling it within a loop and stacking along the zeroth axis. Therefore, the FFI target will be called directly on batched inputs (where the batch axes are the leading dimensions). Additionally, the callbacks should return outputs that have corresponding leading batch axes. If ``vectorized`` is ``False`` (the default behavior), transforming this ``ffi_call`` under :func:`~jax.vmap` will result in a :func:`~jax.lax.scan` with the ``ffi_call`` in the body. Args: target_name: the name of the XLA FFI custom call target that was registered using :func:`~jaxlib.xla_client.register_custom_call_target`. result_shape_dtypes: an object, or sequence of objects, with ``shape`` and ``dtype`` attributes which are expected to match the shape and dtype of the custom call output or outputs. :class:`~jax.ShapeDtypeStruct` is often used to define the elements of ``result_shape_dtypes``. *args: the arguments passed to the custom call. vectorized: boolean specifying whether the callback function can operate in a vectorized manner, as described above. **kwargs: keyword arguments that are passed as named attributes to the custom call using XLA's FFI interface. Returns: One or more :class:`~jax.Array` objects whose shapes and dtypes match ``result_shape_dtypes``. TFc3TK|]#}tj|j|jV$dSr_)r ShapedArrayrarz)rTxs r%rbzffi_call..s3PPat'99PPPPPPr') result_avalsrrr)r{rmapr tuple ffi_call_pbind) rrrrr multiple_resultsrXrrks r%ffi_callrsL#X..*&LL')L,'''PP<PPPPP, O        ' N 1:r'rtuple[core.ShapedArray, ...]c~~~~|Sr_rR)rrrrir s r%ffi_call_abstract_evalrs Z r'c,~~td|dNzThe FFI call to `z\` cannot be differentiated. You can use `jax.custom_jvp` or `jax.custom_jvp` to add support. ValueErrorrrr s r% ffi_call_jvpr6 FI+III J JJr'c,~~td|drrrs r%ffi_call_transposerrr'rIrJrKrLSequence[ir.Value]c8~~t||g|Ri|Sr_)rm)rIrrrrKr s r%ffi_call_loweringrs1J "k " "3 < < < rs)#"""""7777777777  HHHHHHHH$$$$$$******&&&&&&###### EEEEEEEEEEEE-Z  :::::2///D----;?9=8< ------`AAAA>>>>4 888888vJJJJJJ = = = =T^J ' ' "  %I%h&> KKLLL 3444 ,*&8 #*;)*;J+(+(J'z#455555r'