nvmath-python 1.0.0__cp314-cp314t-win_amd64.whl

nvmath/device/common_numba.py

@@ -0,0 +1,300 @@
+# Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. ALL RIGHTS RESERVED.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Callable
+from typing import Any
+
+import llvmlite.ir as llvmir
+import numpy as np
+from llvmlite import ir
+from numba import types
+from numba.core import cgutils, typing
+from numba.core.base import BaseContext
+from numba.core.errors import TypingError
+from numba.cuda.cudaimpl import lower_constant
+from numba.cuda.extending import intrinsic, overload, overload_attribute, register_model
+from numba.extending import models, typeof_impl
+
+from nvmath.bindings import mathdx
+
+from .llvm_array import LLVMArray
+from .types import Complex, Vector, complex32, complex64, complex128, half2, half4, np_float16x2, np_float16x4
+from .vector_types_numba import VectorTypeClass, float16x2_type, float16x4_type, float32x2_type, float64x2_type
+
+NP_TYPES_TO_NUMBA_FE_TYPES = {
+    np.float16: np.float16,
+    np.float32: np.float32,
+    np.float64: np.float64,
+    np_float16x2: float16x2_type,
+    np_float16x4: float16x4_type,
+    np.complex64: float32x2_type,
+    np.complex128: float64x2_type,
+    np.int8: np.int8,
+    np.int16: np.int16,
+    np.int32: np.int32,
+    np.int64: np.int64,
+    np.uint8: np.uint8,
+    np.uint16: np.uint16,
+    np.uint32: np.uint32,
+    np.uint64: np.uint64,
+}
+
+NUMBA_FE_TYPES_TO_NUMBA_IR = {
+    np.float16: types.float16,
+    np.float32: types.float32,
+    np.float64: types.float64,
+    complex32: float16x2_type,
+    complex64: float32x2_type,
+    complex128: float64x2_type,
+    half2: float16x2_type,
+    half4: float16x4_type,
+    float16x2_type: float16x2_type,
+    float16x4_type: float16x4_type,
+    float32x2_type: float32x2_type,
+    float64x2_type: float64x2_type,
+    np.int8: types.int8,
+    np.int16: types.int16,
+    np.int32: types.int32,
+    np.int64: types.int64,
+    np.uint8: types.uint8,
+    np.uint16: types.uint16,
+    np.uint32: types.uint32,
+    np.uint64: types.uint64,
+}
+
+
+class EmptyStructModel(models.StructModel):
+    """Data model that does not take space. Intended to be used with types that
+    are presented only at typing stage and not represented in memory."""
+
+    def __init__(self, dmm, fe_type):
+        members = []
+        super().__init__(dmm, fe_type, members)
+
+
+def overload_type_attribute(numba_type, attribute_base, attribute):
+    """Make type attribute available inside jitted code."""
+    assert issubclass(numba_type, types.Type)
+
+    @overload_attribute(numba_type, attribute, inline="always")
+    def ol_blas_attribute(blas_numba):
+        tp = blas_numba
+        if attribute_base != "":
+            tp = getattr(tp, attribute_base)
+        val = getattr(tp, attribute)
+        return lambda blas_numba: val
+
+
+@typeof_impl.register(Complex)
+def typeof_complex(val: Complex, c: typing.Context) -> Any:
+    return VectorTypeClass(val._numba_type)
+
+
+@typeof_impl.register(Vector)
+def typeof_vector(val: Vector, c: typing.Context) -> Any:
+    return VectorTypeClass(val._numba_type)
+
+
+@intrinsic
+def get_array_ptr(typingctx: typing.Context, arr):
+    """Get raw pointer to the data of a Numba array."""
+    assert isinstance(arr, types.Array)
+
+    sig = typing.signature(types.CPointer(arr.dtype), arr)
+
+    def codegen(context: BaseContext, builder, sig, args):
+        arrTy = sig.args[0]
+        arr = args[0]
+
+        dtype = arrTy.dtype
+        valueTy = context.get_value_type(dtype)
+        ptrTy = ir.PointerType(valueTy)
+        if arr is None:
+            ptr = ptrTy(None)
+        else:
+            ptr = cgutils.create_struct_proxy(arrTy)(context, builder, arr).data
+
+        # Future release of numba-cuda may have support for address spaces.
+        # It is not supported to pass a non generic pointer to device function
+        # call.
+        if ptr.type.addrspace != 0:
+            ptr = builder.addrspacecast(ptr, ir.PointerType(ptr.type.pointee), "generic")
+
+        return ptr
+
+    return sig, codegen
+
+
+def build_get_value_ptr(target_type=None):
+    @intrinsic
+    def get_value_ptr_impl(typingctx: typing.Context, value):
+        """Get raw pointer to the value."""
+        if value not in [float16x2_type, float16x4_type, float32x2_type, float64x2_type] and not isinstance(  # noqa: UP038
+            value, (types.Float, types.Complex, types.Integer)
+        ):
+            raise TypingError(f"get_value_ptr does not support type {value}")
+
+        return_type = target_type if target_type is not None else value
+        sig = typing.signature(types.CPointer(return_type), value)
+
+        def codegen(context: BaseContext, builder, sig, args):
+            if target_type is not None and sig.args[0] != target_type:
+                value = context.cast(builder, args[0], sig.args[0], target_type)
+            else:
+                value = args[0]
+            return cgutils.alloca_once_value(builder, value)
+
+        return sig, codegen
+
+    return get_value_ptr_impl
+
+
+get_value_ptr = build_get_value_ptr()
+get_uint32_value_ptr = build_get_value_ptr(target_type=types.uint32)
+
+
+class MathdxOpaqueTensorType(types.Type):
+    def __init__(self, dynamic_strides_size=0, dynamic_shape_size=0):
+        self.dynamic_strides_size = dynamic_strides_size
+        self.dynamic_shape_size = dynamic_shape_size
+        super().__init__(f"MathdxOpaqueTensor({dynamic_strides_size}, {dynamic_shape_size})")
+
+
+@register_model(MathdxOpaqueTensorType)
+class MathdxOpaqueTensorModel(models.StructModel):
+    def __init__(self, dmm, fe_type: MathdxOpaqueTensorType):
+        members = [("ptr", types.voidptr)]
+
+        if fe_type.dynamic_strides_size > 0:
+            array_type = LLVMArray(types.int64, fe_type.dynamic_strides_size)
+            members += [("strides", array_type)]
+
+        if fe_type.dynamic_shape_size > 0:
+            array_type = LLVMArray(types.int64, fe_type.dynamic_shape_size)
+            members += [("shape", array_type)]
+
+        models.StructModel.__init__(self, dmm, fe_type, members)
+
+    def get_value_type(self):
+        if self._value_type is None:
+            name = f"struct.libmathdx_tensor_{self._fe_type.dynamic_strides_size}s_{self._fe_type.dynamic_shape_size}s"
+            t = llvmir.global_context.get_identified_type(name)
+            if t.is_opaque:
+                t.set_body(*[m.get_value_type() for m in self._models])
+            self._value_type = t
+        return self._value_type
+
+
+class MathdxPipelineType(types.Type):
+    def __init__(self):
+        super().__init__("MathdxPipeline()")
+
+
+@register_model(MathdxPipelineType)
+class MathdxPipelineModel(models.StructModel):
+    def __init__(self, dmm, fe_type: MathdxPipelineType):
+        members = [("ptr", types.voidptr)]
+        models.StructModel.__init__(self, dmm, fe_type, members)
+
+    def get_value_type(self):
+        if self._value_type is None:
+            name = "struct.libmathdx_pipeline"
+            t = llvmir.global_context.get_identified_type(name)
+            if t.is_opaque:
+                t.set_body(*[m.get_value_type() for m in self._models])
+            self._value_type = t
+        return self._value_type
+
+
+@intrinsic
+def cast_to_void_pointer(typingctx: typing.Context, ptr_ty):
+    if not isinstance(ptr_ty, types.CPointer):
+        raise TypingError("cast_to_void_pointer expects a CPointer type")
+    i8_ptr_ty = types.CPointer(types.uint8)
+    sig = i8_ptr_ty(ptr_ty)
+
+    def codegen(context: BaseContext, builder, sig, args):
+        return builder.bitcast(args[0], context.get_value_type(i8_ptr_ty))
+
+    return sig, codegen
+
+
+_cabi_device_registry: dict[str | tuple[str, typing.Signature], Callable] = {}
+
+
+def declare_cabi_device(symbol: str, sig: typing.Signature, link=None):
+    """declare_cabi_device is an analog of cuda.declare_device but uses C ABI
+    calling convention instead of Numba ABI calling convention. It means that
+    the first argument is not a return value pointer."""
+    key: str | tuple[str, typing.Signature] = symbol
+    if mathdx.get_version_ex() < (0, 3, 0):
+        key = (symbol, sig)
+    device_func = _cabi_device_registry.get(key)
+    if device_func is None:
+        device_func = _declare_cabi_device(symbol, sig, link)
+        _cabi_device_registry[key] = device_func
+
+    return device_func
+
+
+def _declare_cabi_device(symbol: str, sig: typing.Signature, link=None):
+    intrinsic_sig = sig.return_type(types.Tuple(sig.args))
+
+    @intrinsic
+    def call_device(typingctx: typing.Context, args):
+        def codegen(context: BaseContext, builder, sig: typing.Signature, args):
+            if link is not None:
+                context.active_code_library.add_linking_file(link)
+
+            args = cgutils.unpack_tuple(builder, args[0])
+            argTypes = sig.args[0]
+
+            assert len(args) == len(argTypes)
+
+            # CUDA target maps types.void to i8*, but we need void for abi correctness.
+            if sig.return_type == types.void:
+                retTy = ir.VoidType()
+            else:
+                retTy = context.get_value_type(sig.return_type)
+            fnTy = ir.FunctionType(retTy, [context.get_value_type(argTy) for argTy in argTypes])
+            fn = cgutils.get_or_insert_function(builder.module, fnTy, symbol)
+            builder.call(fn, args)
+
+        return intrinsic_sig, codegen
+
+    def device_func():
+        pass
+
+    @overload(device_func, jit_options={"forceinline": True})
+    def ol_device_func(*args):
+        if len(args) != len(sig.args):
+            raise RuntimeError(
+                f"Invalid number of arguments for device function {symbol}: expected {len(sig.args)}, got {len(args)}"
+            )
+        for expected_t, provided_t in zip(sig.args, args, strict=True):
+            if expected_t == provided_t:
+                continue
+            raise RuntimeError(f"Invalid argument type for device function {symbol}: expected {expected_t}, got {provided_t}")
+        return lambda *args: call_device(tuple(args))
+
+    return device_func
+
+
+def register_dummy_numba_type(numba_type, base_type, name, attributes):
+    """Register and lower a dummy Numba type that does not take space in memory.
+    Intended for types that are present only at typing stage and not represented in memory,
+    but are allowed to be accessed inside kernel."""
+    for attribute in attributes:
+        overload_type_attribute(numba_type, name, attribute)
+
+    @typeof_impl.register(base_type)
+    def typeof_numba(val, context):
+        return numba_type(val)
+
+    register_model(numba_type)(EmptyStructModel)
+
+    @lower_constant(numba_type)
+    def constant_dummy(context, builder, typ, pyval):
+        struct_ptr = cgutils.create_struct_proxy(typ)(context, builder)
+        return struct_ptr._getvalue()

nvmath/device/common_numba_cuda_mlir.py

@@ -0,0 +1,202 @@
+# Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. ALL RIGHTS RESERVED.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+from collections.abc import Iterable
+from typing import Any
+
+import cffi
+import numpy as np
+from numba_cuda_mlir import cuda
+from numba_cuda_mlir._mlir.dialects import llvm
+from numba_cuda_mlir._mlir.extras import types as T
+from numba_cuda_mlir.cuda import vector_types
+from numba_cuda_mlir.extending import lowering_registry, overload, overload_attribute, typing_registry
+from numba_cuda_mlir.lowering_utilities import to_mlir_type, unverified_convert
+from numba_cuda_mlir.lowering_utilities.type_conversions import to_numba_type
+from numba_cuda_mlir.models import PrimitiveModel
+from numba_cuda_mlir.models import register_model as numba_cuda_mlir_register_model
+from numba_cuda_mlir.numba_cuda import types
+from numba_cuda_mlir.numba_cuda.extending import typeof_impl
+from numba_cuda_mlir.numba_cuda.np import numpy_support
+from numba_cuda_mlir.type_defs.vector_types import VectorType
+
+from .types import Complex, Vector
+
+__all__ = [
+    "HostDescriptorBase",
+    "overload_type_attribute",
+    "register_dummy_type",
+    "get_array_pointer",
+]
+
+# ==========================
+# Argument-conversion helpers for JIT bodies
+# ==========================
+
+_FFI = cffi.FFI()
+
+
+@cuda.jit(device=True, forceinline=True)
+def get_array_pointer(arr):
+    return _FFI.from_buffer(arr)
+
+
+@cuda.jit(device=True, inline="always")
+def int_to_uint32_ptr(val):
+    local = cuda.local.array(shape=(1,), dtype=np.uint32)
+    local[0] = val
+    return _FFI.from_buffer(local)
+
+
+@cuda.jit(device=True, forceinline=True)
+def passthrough(val):
+    return val
+
+
+def get_value_ptr(value: Any) -> int:
+    raise NotImplementedError("get_value_ptr is callable only from jitted code")
+
+
+@overload(get_value_ptr, strict=False, inline="always", typing_registry=typing_registry)
+def ol_get_value_ptr(value):
+    # TODO(numba-cuda-mlir): Known complex types work correctly,
+    # but types.Complex("complex32",types.float16) currently fails.
+    # For now, handle all complex types here explicitly.
+    # Ideally, all of this should be replaced by a generic as_dtype path.
+    dtype = value if isinstance(value, (VectorType, types.Complex)) else numpy_support.as_dtype(value).type
+
+    def impl(value):
+        local = cuda.local.array(shape=(1,), dtype=dtype)
+        local[0] = value
+        return _FFI.from_buffer(local)
+
+    return impl
+
+
+# ==========================
+# Type registration helpers
+# ==========================
+
+
+class HostDescriptorBase(types.Type):
+    """
+    Base numba type wrapping a host descriptor,
+    subclass per API (cufftdx, cusolverdx, ...).
+    """
+
+    def __init__(
+        self,
+        host_descriptor,
+        definition_args: Iterable[str],
+        type_kind: str,
+    ) -> None:
+        self._host_descriptor = host_descriptor
+
+        attributes = [
+            f"{attr}={getattr(host_descriptor, attr)}" for attr in definition_args if getattr(host_descriptor, attr, None)
+        ]
+        attributes.sort()
+
+        super().__init__(f"{type_kind}({','.join(attributes)})")
+
+    @property
+    def host_descriptor(self):
+        return self._host_descriptor
+
+
+def overload_type_attribute(
+    numba_type: type[types.Type],
+    attribute_base: str,
+    attribute: str,
+) -> None:
+    """Make type attribute available inside jitted code."""
+    assert issubclass(numba_type, types.Type)
+
+    @overload_attribute(
+        numba_type,
+        attribute,
+        inline="always",
+        typing_registry=typing_registry,
+        lowering_registry=lowering_registry,
+    )
+    def ol_attribute(api_numba):
+        tp = api_numba
+        if attribute_base != "":
+            tp = getattr(tp, attribute_base)
+        val = getattr(tp, attribute)
+        return lambda api_numba: val
+
+
+class _DummyMlirModel(PrimitiveModel):
+    """Shared data model for numba types that have no runtime memory footprint."""
+
+    def __init__(self, dmm, fe_type) -> None:
+        super().__init__(dmm, fe_type, T.i8())
+
+
+def register_dummy_type(
+    numba_type: type[types.Type],
+    base_type: type,
+    attributes: Iterable[str],
+    *,
+    attribute_base: str | None = None,
+) -> None:
+    """
+    Register a dummy numba-cuda-mlir type that exists only at typing time.
+
+    Bundles five effects:
+      * typeof_impl.register(base_type)
+      * register_model(numba_type) with the shared dummy PrimitiveModel
+      * to_mlir_type.register(numba_type) returning T.i8()
+      * unverified_convert.register(base_type) returning llvm.mlir_undef(T.i8())
+      * an overload_type_attribute(numba_type, attribute_base, attribute)
+        for each name in attributes.
+    """
+    if attribute_base is None and issubclass(numba_type, HostDescriptorBase):
+        attribute_base = "host_descriptor"
+    assert attribute_base is not None
+
+    @typeof_impl.register(base_type)
+    def _typeof(val, context):
+        return numba_type(val)
+
+    numba_cuda_mlir_register_model(numba_type)(_DummyMlirModel)
+
+    @to_mlir_type.register(numba_type)
+    def _to_mlir(val, context):
+        return T.i8()
+
+    @unverified_convert.register(base_type)
+    def _unverified_convert(val, target_type, signed: bool = False):
+        assert target_type == T.i8()
+        return llvm.mlir_undef(T.i8())
+
+    for attribute in attributes:
+        overload_type_attribute(numba_type, attribute_base, attribute)
+
+
+# ==========================
+# Vector/Complex typing
+# ==========================
+
+
+@to_numba_type.register(Vector)
+def _(val: Vector) -> types.Type:
+    return getattr(vector_types, f"{np.dtype(val.real_dtype).name}x{val.size}")
+
+
+@to_numba_type.register(Complex)
+def _(val: Complex) -> types.Type:
+    # real_type = to_numba_type(val.real_dtype)
+    real_type = to_numba_type(np.dtype(val.real_dtype))
+    assert isinstance(real_type, types.Float)
+    return types.Complex(f"complex{real_type.bitwidth * 2}", real_type)
+
+
+# TODO: do we need both to_numba_type and typeof_impl for Vector and Complex?
+@typeof_impl.register(Vector)
+@typeof_impl.register(Complex)
+def _typeof_host_type(val, c):
+    return typeof_impl(to_numba_type(val), c)

nvmath/device/common_opaque_tensor.py

@@ -0,0 +1,201 @@
+# Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. ALL RIGHTS RESERVED.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from functools import cached_property
+
+import numpy
+from llvmlite import ir as llir
+from numba.core import cgutils
+from numba.core.base import BaseContext
+from numba.cuda.extending import lower_builtin, make_attribute_wrapper, type_callable
+from numba.cuda.models import register_model
+from numba.extending import models, types
+
+from nvmath.device.common import Layout, OpaqueTensor
+from nvmath.device.common_numba import NUMBA_FE_TYPES_TO_NUMBA_IR, overload_type_attribute
+from nvmath.device.llvm_array import LLVMArray
+
+_LIBMATHDX_RUNTIME = -9223372036854775808
+
+
+class OpaqueLayout(Layout):
+    """
+    A generic tensor layout that can represent arbitrary shapes and strides.
+    It is the same as libmathdx opaque tensor, but without the pointer
+    to data.
+    """
+
+    _dtype: numpy.number
+    _shape: tuple[int, ...]
+    _strides: tuple[int, ...]
+
+    def __init__(self, shape: tuple[int, ...], strides: tuple[int, ...], dtype: numpy.number):
+        assert len(shape) == len(strides)
+        self._shape = shape
+        self._strides = strides
+        self._dtype = dtype
+
+    @cached_property
+    def dynamic_strides_size(self) -> int:
+        return self._strides.count(_LIBMATHDX_RUNTIME)
+
+    @cached_property
+    def dynamic_shape_size(self) -> int:
+        return self._shape.count(_LIBMATHDX_RUNTIME)
+
+    @property
+    def dtype(self) -> numpy.number:
+        return self._dtype
+
+    @cached_property
+    def ndim(self) -> int:
+        return len(self._shape)
+
+    @property
+    def shape(self) -> tuple[int, ...]:
+        return self._shape
+
+    @property
+    def strides(self) -> tuple[int, ...]:
+        return self._strides
+
+
+class LayoutType(types.Type):
+    """
+    Type class associated with opaque tensor layouts.
+    """
+
+    def __init__(
+        self,
+        layout: OpaqueLayout,
+    ):
+        self._layout = layout
+        super().__init__(
+            f"Layout(dynamic_shape_size={layout.dynamic_shape_size}, dynamic_strides_size={layout.dynamic_strides_size})"
+        )
+
+    @property
+    def layout(self) -> OpaqueLayout:
+        return self._layout
+
+    @cached_property
+    def dtype(self) -> types.Number:
+        return NUMBA_FE_TYPES_TO_NUMBA_IR[self._layout.dtype]
+
+
+@register_model(LayoutType)
+class LayoutModel(models.StructModel):
+    def __init__(self, dmm, fe_type: LayoutType):
+        members = []
+
+        strides_size = fe_type.layout.dynamic_strides_size
+        if strides_size > 0:
+            array_type = LLVMArray(types.int64, strides_size)
+            members += [("strides", array_type)]
+
+        shape_size = fe_type.layout.dynamic_shape_size
+        if shape_size > 0:
+            array_type = LLVMArray(types.int64, shape_size)
+            members += [("shape", array_type)]
+
+        models.StructModel.__init__(self, dmm, fe_type, members)
+
+
+make_attribute_wrapper(LayoutType, "strides", "strides")
+make_attribute_wrapper(LayoutType, "shape", "shape")
+
+for attribute in ("uid", "alignment", "storage_bytes"):
+    overload_type_attribute(LayoutType, "", attribute)
+
+
+class OpaqueTensorType(types.Type):
+    def __init__(self, layout: LayoutType):
+        super().__init__(f"OpaqueTensor(layout={layout})")
+        self._layout = layout
+
+    @property
+    def uid(self):
+        return self._layout.layout.uid
+
+    @property
+    def layout(self) -> LayoutType:
+        return self._layout
+
+    @cached_property
+    def ndim(self):
+        return 2
+
+    @cached_property
+    def dtype(self):
+        return self._layout.dtype
+
+
+class OpaqueTensorModel(models.StructModel):
+    def __init__(self, dmm, fe_type: OpaqueTensorType):
+        members = [
+            ("ptr", types.voidptr),
+        ]
+        layout = fe_type.layout.layout
+
+        strides_size = layout.dynamic_strides_size
+        if strides_size > 0:
+            array_type = LLVMArray(types.int64, strides_size)
+            members += [("strides", array_type)]
+
+        shape_size = layout.dynamic_shape_size
+        if shape_size > 0:
+            array_type = LLVMArray(types.int64, shape_size)
+            members += [("shape", array_type)]
+
+        models.StructModel.__init__(self, dmm, fe_type, members)
+
+
+register_model(OpaqueTensorType)(OpaqueTensorModel)
+
+
+@type_callable(OpaqueTensor)
+def type_callable_OpaqueTensor(context):
+    def typer(buffer_ty, layout_ty):
+        if not isinstance(buffer_ty, types.Array):
+            return
+        if not isinstance(layout_ty, LayoutType):
+            return
+        assert buffer_ty.dtype == layout_ty.dtype
+        return OpaqueTensorType(layout_ty)
+
+    return typer
+
+
+@lower_builtin(OpaqueTensor, types.Array, LayoutType)
+def impl_opaque_tensor(context: BaseContext, builder: llir.IRBuilder, sig, args):
+    tensor_ty: OpaqueTensorType = sig.return_type
+    buffer, buffer_ty = args[0], sig.args[0]
+    layout, layout_ty = args[1], sig.args[1]
+
+    ptr = cgutils.create_struct_proxy(buffer_ty)(context, builder, buffer).data
+    # Future release of numba-cuda may have support for address spaces.
+    # It is not supported to pass a non generic pointer to device function
+    # call.
+    if ptr.type.addrspace != 0:
+        ptr = builder.addrspacecast(ptr, llir.PointerType(ptr.type.pointee), "generic")
+
+    voidPtrTy = llir.PointerType(llir.IntType(8))
+    ptr = builder.bitcast(ptr, voidPtrTy)
+
+    opaque_tensor = cgutils.create_struct_proxy(tensor_ty)(context, builder)
+    opaque_tensor.ptr = ptr
+
+    layout_struct = cgutils.create_struct_proxy(layout_ty)(context, builder, layout)
+
+    if tensor_ty.layout.layout.dynamic_shape_size > 0:
+        opaque_tensor.shape = layout_struct.shape
+
+    if tensor_ty.layout.layout.dynamic_strides_size > 0:
+        opaque_tensor.strides = layout_struct.strides
+
+    return opaque_tensor._getvalue()
+
+
+make_attribute_wrapper(OpaqueTensorType, "ptr", "ptr")
+overload_type_attribute(OpaqueTensorType, "layout", "layout")