code: def _tile(cls, op):
      df = op.inputs[0]
  
      if op.axis == 0:
          if df.chunk_shape[op.axis] == 1:
              if op.output_types[0] == OutputType.dataframe:
                  df = build_concatenated_rows_frame(df)
                  out_chunks = []
                  for chunk in df.chunks:
                      chunk_op = op.copy().reset_key()
                      out_chunks.append(
                          chunk_op.new_chunk(
                              [chunk],
                              shape=chunk.shape,
                              index=chunk.index,
                              index_value=chunk.index_value,
                              columns_value=chunk.columns_value,
                              dtypes=chunk.dtypes,
                          )
                      )
                  new_op = op.copy()
                  kws = op.outputs[0].params.copy()
                  kws["nsplits"] = df.nsplits
                  kws["chunks"] = out_chunks
                  return new_op.new_dataframes(op.inputs, **kws)
              else:
                  out_chunks = []
                  for chunk in df.chunks:
                      chunk_op = op.copy().reset_key()
                      out_chunks.append(
                          chunk_op.new_chunk(
                              [chunk],
                              shape=chunk.shape,
                              index=chunk.index,
                              index_value=chunk.index_value,
                              name=chunk.name,
                              dtype=chunk.dtype,
                          )
                      )
                  new_op = op.copy()
                  kws = op.outputs[0].params.copy()
                  kws["nsplits"] = df.nsplits
                  kws["chunks"] = out_chunks
                  return new_op.new_seriess(op.inputs, **kws)
          else:
              if op.output_types[0] == OutputType.dataframe:
                  df = build_concatenated_rows_frame(df)
              if op.na_position != "last":  # pragma: no cover
                  raise NotImplementedError(
                      "Only support puts NaNs at the end."
                  )
              # use parallel sorting by regular sampling
              return (yield from cls._tile_psrs(op, df))
      else:
          assert op.axis == 1
  
          sorted_columns = list(
              df.columns_value.to_pandas().sort_values(
                  ascending=op.ascending
              )
          )
          r = [(yield from recursive_tile(df[sorted_columns]))]
          if op.ignore_index:
              chunks = r[0].chunks
              yield chunks
              out = op.outputs[0]
              chunks = standardize_range_index(chunks, axis=0)
              new_op = op.copy()
              return new_op.new_dataframes(
                  op.inputs,
                  shape=out.shape,
                  chunks=chunks,
                  nsplits=calc_nsplits(
                      {c.index: c.shape for c in chunks}
                  ),
                  index_value=out.index_value,
                  columns_value=out.columns_value,
                  dtypes=out.dtypes,
              )
          return r
  
file_path: mars/mars/dataframe/sort/sort_index.py
imports: import pandas
  from ...None import opcodes
  from ...core import OutputType, recursive_tile
  from ...serialization.serializables import ListField, BoolField
  from ...tensor.base.sort import _validate_sort_psrs_kinds
  from ...utils import calc_nsplits
  from ..utils import parse_index, validate_axis, build_concatenated_rows_frame, standardize_range_index
  from ..operands import DATAFRAME_TYPE
  from .core import DataFrameSortOperand
  from .psrs import DataFramePSRSOperandMixin, execute_sort_index
label_desc: Use image node_id 1 for calling the DataFrameSortIndex obj's underlying member method code with example usage: obj._tile(cls, op) and returns: r, unknown, new_op, new_op, new_op