code: def full(
      shape,
      fill_value,
      dtype=None,
      chunk_size=None,
      gpu=None,
      order="C",
  ):
      """
      Return a new tensor of given shape and type, filled with `fill_value`.
  
      Parameters
      ----------
      shape : int or sequence of ints
          Shape of the new tensor, e.g., ``(2, 3)`` or ``2``.
      fill_value : scalar
          Fill value.
      dtype : data-type, optional
          The desired data-type for the tensor  The default, `None`, means
           `np.array(fill_value).dtype`.
      chunk_size : int or tuple of int or tuple of ints, optional
          Desired chunk size on each dimension
      gpu : bool, optional
          Allocate the tensor on GPU if True, False as default
      order : {'C', 'F'}, optional
          Whether to store multidimensional data in C- or Fortran-contiguous
          (row- or column-wise) order in memory.
  
      Returns
      -------
      out : Tensor
          Tensor of `fill_value` with the given shape, dtype, and order.
  
      See Also
      --------
      zeros_like : Return a tensor of zeros with shape and type of input.
      ones_like : Return a tensor of ones with shape and type of input.
      empty_like : Return an empty tensor with shape and type of input.
      full_like : Fill a tensor with shape and type of input.
      zeros : Return a new tensor setting values to zero.
      ones : Return a new tensor setting values to one.
      empty : Return a new uninitialized tensor.
  
      Examples
      --------
      >>> import mars.tensor as mt
  
      >>> mt.full((2, 2), mt.inf).execute()
      array([[ inf,  inf],
             [ inf,  inf]])
      >>> mt.full((2, 2), 10).execute()
      array([[10, 10],
             [10, 10]])
  
      """
      v = np.asarray(fill_value)
      if len(v.shape) > 0:
          from ..base import broadcast_to
  
          return broadcast_to(
              tensor(
                  v,
                  dtype=dtype,
                  chunk_size=chunk_size,
                  gpu=gpu,
                  order=order,
              ),
              shape,
          )
  
      tensor_order = get_order(
          order,
          None,
          available_options="CF",
          err_msg="only 'C' or 'F' order is permitted",
      )
      op = TensorFull(fill_value, dtype=dtype, gpu=gpu, order=order)
      return op(shape, chunk_size=chunk_size, order=tensor_order)
  
imports: import numpy
  from ...None import opcodes
  from ...serialization.serializables import AnyField, StringField, KeyField
  from ...lib.sparse.core import get_sparse_module, get_array_module, naked
  from ...lib.sparse import SparseNDArray
  from ..array_utils import create_array
  from ..utils import get_order
  from .core import TensorNoInput, TensorLike
  from .array import tensor
label_desc: Use image node_id 1 for calling a global function with example usage: full(shape, fill_value, dtype, chunk_size, gpu, order) and returns: op, broadcast_to