o e«Ïià0ã @sþUdZddlmZddlmZddlmZddlmZm Z m Z m Z ddl m Z ddlmZddlZdd lmZmZd d lmZGd d „d eƒZedƒGdd„dƒƒZdZe dejjƒZeGdd„dƒƒZeƒZeeefed<iZe e!efed<dede!fdd„Z"ddddœdede!dede e!efdBddf d d!„Z#d"e$de efd#d$„Z%dede&fd%d&„Z'dede&fd'd(„Z(dede&fd)d*„Z)dede&fd+d,„Z*dede&fd-d.„Z+d/ede,e!e e!e-fffd0d1„Z.dede efd2d3„Z/ded4e!de efd5d6„Z0dS)7aM Note [Opaque Objects] Opaque objects are the way we allow custom operators to accept a user-defined "black box" object as an input. There are two kinds of opaque types: VALUE type and REFERENCE type. The distinction determines how torch.compile handles the object. REFERENCE TYPES (default): Reference-typed opaque objects represent mutable stateful objects and are treated as black boxes. In torch.compile, since torch.compile cannot optimize the anything (including tensors) within the object, the object must be an input to the graph. You can register a custom class as being a reference-based opaque object class through `register_opaque_type(MyClass, typ="reference")`. VALUE TYPES: Value-typed opaque objects represent constant values. In torch.compile, the graph specializes on the object like how other constants are. Therefore there are a couple of methods on the class that must be implemented before registering it as a value-typed opaque object class: - __eq__: torch.compile will create guards based on the equality of this object, meaning that a recompilation will happen if __eq__ returns False. - __hash__: This must be implemented for Fake Tensor caching - __fx_repr__: This must be implemented to provide an evaluable representation for FX graph codegen. It should return a tuple of (repr_string, dict[str, type]) where repr_string can reconstruct the object and the dict maps names used in repr_string to their corresponding types. You can register a custom class as being a reference-based opaque object class through `register_opaque_type(MyClass, typ="value")`. é)ÚCallable)Ú dataclass)ÚEnum)ÚAnyÚLiteralÚNewTypeÚOptional)ÚTypeIs)ÚWeakKeyDictionaryN)Ú OpaqueBaseÚOpaqueBaseMetaé)Úregister_fake_classc@seZdZdZdZdZdS)Ú MemberTypez{ Defines how a member (attribute/property/method) of an opaque object is handled during torch.compile tracing. Úuse_realÚinlinedN)Ú__name__Ú __module__Ú __qualname__Ú__doc__ÚUSE_REALÚINLINED©rrúf/var/www/addictedbytheproject.nl/epg/venv/lib/python3.10/site-packages/torch/_library/opaque_object.pyr3srzaten::OpaqueObjectc@s4eZdZddd„Zedeeefddfdd„ƒZdS) ÚFakeOpaqueObjectÚreturnNcCsdS©Nr)ÚselfrrrÚ__init__AszFakeOpaqueObject.__init__Ú flattened_ctxcCstdƒ‚)NzFakeOpaqueObject should not be created through __obj_unflatten__ and should be special handled. Please file an issue to Github.)Ú RuntimeError)ÚclsrrrrÚ__obj_unflatten__Dsÿz"FakeOpaqueObject.__obj_unflatten__)rN) rrrrÚ classmethodÚdictÚstrrr"rrrrr?s  rz)__torch__.torch.classes.aten.OpaqueObjectÚ OpaqueTypec@sPeZdZUeed<eded<eegeefed<e ee fed<e ed<dS)Ú_OpaqueTypeInfoÚ class_name©Ú referenceÚvalueÚ opaque_typÚguard_fnÚmembersÚhoistN) rrrr%Ú__annotations__rrrÚlistr$rÚboolrrrrr'Qs   ÿ r'Ú _OPAQUE_TYPESÚ_OPAQUE_TYPES_BY_NAMEr!rcCs*|tvrtd|›d|j›dƒ‚t|jS)a Gets the registered opaque type name for a given class. Args: cls (type): The class to get the type name for. Returns: str: The registered type name for the class. Raises: ValueError: If the class is not registered as an opaque type. zClass z@ is not registered as an opaque type. Call register_opaque_type(z) first.)r3Ú ValueErrorrr(©r!rrrÚget_opaque_type_namebs ÿÿ r7F)r/r-r.Útypr-r.cCs4ddlmm}|jdks|tjurtd|›dƒ‚||jvr't|›dƒ‚t|t ƒs4t d|›dƒ‚|d vr?t d |›ƒ‚|d krw|j t j urQt d |›d ƒ‚|jdur^t d |›dƒ‚t|dƒskt d |›dƒ‚|durwt d|›dƒ‚|j›d|j›}t||||p‡i|ƒ}|t|<|t|<tj |¡dS)aœ Registers the given type as an opaque type which allows this to be consumed by a custom operator. The type name will be automatically generated from the class's fully qualified name (ex. my_module.MyClass). Args: cls (type): The class to register as an opaque type. typ (str): Either "reference" or "value". See Note [Opaque Objects] for more details. hoist (bool): Only applies to value types. A hoist=True value type object is lifted as an input to the torch.compile'd graph, instead of being a constant baked into the graph. This is useful to improve compilation times in hierarchical compilation (e.g., change your custom ops to use hoisted strings to avoid baking the string into the Dynamo/AOTAutograd/FX graphs). This flag does nothing for reference types. guard_fn (callable | None): A function that takes an instance of the opaque object and returns a list of values to guard on. These values will be compared for equality on each function call, triggering recompilation if they change. Only applicable for reference types. Example: lambda obj: [obj.x, obj.y] members (dict[str, MemberType] | None): Dictionary mapping member names (attributes, properties, or methods) to their MemberType, which controls how they are handled during torch.compile tracing: - MemberType.USE_REAL: Evaluates with the real object at compile time and bakes the result as a constant - MemberType.INLINED: Inlines the method call into the trace rNÚbuiltinsz!Unable to register built-in type z] as an opaque type. Please wrap it in a custom class and register the custom class as opaque.zv cannot be registered as an opaque object as it has been registered as a pytree. Opaque objects must be pytree leaves.z Opaque type zõ must subclass torch._opaque_base.OpaqueBase or 'metaclass=torch._opaque_base.OpaqueBaseMeta'. This is required so that FakeScriptObject can be registered as a virtual subclass, allowing isinstance() checks to work during torch.compile tracing. r)z7Opaque type must be either 'reference' or 'value', got r+ú!Value-type opaque object of type z„ is expected to have a non-default `__eq__` implementation as we will use this in torch.compile to guard on the equality of objects.zy is expected to have a non-default `__hash__` implementation as we will use this in torch.compile for FakeTensor caching.Ú __fx_repr__z½ is expected to have a `__fx_repr__` method implementation as we will use this to reconstruct the object in the FX codegen. __fx_repr__ should return a tuple of (repr_string, set_of_types).z:No need to specify `guard_fn` for value-type opaque class z) as it will be guarded based on `__eq__`.Ú.)Útorch.utils._pytreeÚutilsÚ_pytreerÚtorchÚTensorr5ÚSUPPORTED_NODESÚ isinstancer Ú TypeErrorÚAssertionErrorÚ__eq__ÚobjectÚ__hash__Úhasattrrr'r3r4Ú_CÚ_register_opaque_type)r!r8r/r-r.ÚpytreeÚnameÚ type_inforrrÚregister_opaque_typewsR& ÿ ÿ  ÿÿ  ÿ  ÿ  ÿÿÿrOr+cCs tt|ƒƒSr)Úis_opaque_typeÚtype)r+rrrÚis_opaque_valueçs rRcCs|tvrdSt|jS)NF)r3r/r6rrrÚ should_hoistës rScCs|tvrdStt|jƒdkS)NFr)r3Úlenr.r6rrrÚ has_membersñsrUcCs4t|tƒr tj |¡S|tvrdStj t|j¡S)z5 Checks if the given type is an opaque type. F)rCr%r@rJÚ_is_opaque_type_registeredr3r(r6rrrrP÷s  rPcCó2t|ƒsdSt|tƒrt|jdkSt|jdkS)zs Checks if the given type is an opaque **value** type. See Note [Opaque Objects] for more information. Fr+©rPrCr%r4r,r3r6rrrÚis_opaque_value_typeó  rYcCrW)zw Checks if the given type is an opaque **reference** type. See Note [Opaque Objects] for more information. Fr*rXr6rrrÚis_opaque_reference_typerZr[ÚobjcCs‚t|dƒs td|›dƒ‚| ¡\}}t|tƒs(tdt|ƒj›dt|ƒj›ƒ‚t|tƒs=tdt|ƒj›dt|ƒj›ƒ‚||fS)aÄ Get the FX-evaluable repr for an opaque object and collect required globals. Objects must implement __fx_repr__() which should return: (repr_string, dict_mapping_name_to_type) where repr_string is an evaluable string representation and dict_mapping_name_to_type maps the names used in repr_string to their types. For example, if repr_string is "Foo(bar=Bar(1))", the dict should be: {"Foo": Foo, "Bar": Bar} r;r:zÀ is expected to have a `__fx_repr__` method implementation as we will use this to reconstruct the object in the FX codegen. __fx_repr__ should return a tuple of (repr_string, dict[str, type]).z__fx_repr__ for z0 must return a string as the first element, got z/ must return a dict as the second element, got )rIrDr;rCr%rQrr$)r\Úrepr_strÚ globals_dictrrrÚget_opaque_obj_repr s$  ÿ  ÿÿ ÿÿr_cCs&t|ƒsdSt|tƒrt|St|Sr)rPrCr%r4r3r6rrrÚget_opaque_obj_infoGs  r`Ú member_namecCs t|ƒ}|dur dS|j |¡S)a Get the MemberType for a specific member of an opaque object class. Args: cls: The opaque object class (or its string name) member_name: The name of the member to query Returns: MemberType if the member is registered, None otherwise N)r`r.Úget)r!raÚinforrrÚget_member_typeQs  rd)1rÚcollections.abcrÚ dataclassesrÚenumrÚtypingrrrrÚtyping_extensionsr Úweakrefr r@Útorch._opaque_baser r Úfake_class_registryrrrÚ OpaqueTypeStrrJÚ ScriptObjectr&r'r3r0r4r$r%r7rOrGrRr2rSrUrPrYr[ÚtuplerQr_r`rdrrrrÚsV %        úÿýûú ùp "'