text: Title: [BUG] df.sort_values() failed when input dataframe is empty
  Body: <!--
  Thank you for your contribution!
  
  Please review https://github.com/mars-project/mars/blob/master/CONTRIBUTING.rst before opening an issue.
  -->
  
  **Describe the bug**
  
  df.sort_values() failed when input dataframe is empty.
  
  **To Reproduce**
  To help us reproducing this bug, please provide information below:
  1. Your Python version
  2. The version of Mars you use
  3. Versions of crucial packages, such as numpy, scipy and pandas
  4. Full stack of the error.
  5. Minimized code to reproduce the error.
  
  ```
  In [13]: import mars.tensor as mt
  
  In [14]: import mars.dataframe as md
  
  In [15]: df = md.DataFrame(mt.random.rand(4, 3, chunk_size=3))
  
  In [16]: df = df[df[0] > 1].execute()
  100%|██████████████████████████████████████| 100.0/100 [00:00<00:00, 217.32it/s]
  
  In [17]: df.sort_values(by=2).execute()
    0%|                                                   | 0/100 [00:00<?, ?it/s]Unexpected error happens in <function TaskProcessor.get_next_stage_processor at 0x7f9487bc6430>
  Traceback (most recent call last):
    File "/Users/qinxuye/Workspace/mars/mars/services/task/supervisor/processor.py", line 57, in inner
      return await func(processor, *args, **kwargs)
    File "/Users/qinxuye/Workspace/mars/mars/services/task/supervisor/processor.py", line 336, in get_next_stage_processor
      chunk_graph = await self._get_next_chunk_graph(self._chunk_graph_iter)
    File "/Users/qinxuye/Workspace/mars/mars/services/task/supervisor/processor.py", line 266, in _get_next_chunk_graph
      chunk_graph = await fut
    File "/Users/qinxuye/Workspace/mars/mars/lib/aio/_threads.py", line 36, in to_thread
      return await loop.run_in_executor(None, func_call)
    File "/Users/qinxuye/miniconda3/envs/mars3.8/lib/python3.8/concurrent/futures/thread.py", line 57, in run
      result = self.fn(*self.args, **self.kwargs)
    File "/Users/qinxuye/Workspace/mars/mars/services/task/supervisor/processor.py", line 261, in next_chunk_graph
      return next(chunk_graph_iter)
    File "/Users/qinxuye/Workspace/mars/mars/services/task/supervisor/preprocessor.py", line 158, in tile
      for chunk_graph in chunk_graph_builder.build():
    File "/Users/qinxuye/Workspace/mars/mars/core/graph/builder/chunk.py", line 272, in build
      yield from self._build()
    File "/Users/qinxuye/Workspace/mars/mars/core/graph/builder/chunk.py", line 266, in _build
      graph = next(tile_iterator)
    File "/Users/qinxuye/Workspace/mars/mars/services/task/supervisor/preprocessor.py", line 75, in __iter__
      to_update_tileables = self._iter()
    File "/Users/qinxuye/Workspace/mars/mars/core/graph/builder/chunk.py", line 198, in _iter
      self._tile(
    File "/Users/qinxuye/Workspace/mars/mars/core/graph/builder/chunk.py", line 113, in _tile
      need_process = next(tile_handler)
    File "/Users/qinxuye/Workspace/mars/mars/core/graph/builder/chunk.py", line 84, in _tile_handler
      tiled_tileables = yield from handler.tile(tiled_tileables)
    File "/Users/qinxuye/Workspace/mars/mars/core/entity/tileables.py", line 79, in tile
      tiled_result = yield from tile_handler(op)
    File "/Users/qinxuye/Workspace/mars/mars/dataframe/sort/core.py", line 181, in tile
      return (yield from cls._tile(op))
    File "/Users/qinxuye/Workspace/mars/mars/dataframe/sort/sort_values.py", line 98, in _tile
      return (yield from cls._tile_dataframe(op))
    File "/Users/qinxuye/Workspace/mars/mars/dataframe/sort/sort_values.py", line 66, in _tile_dataframe
      return (yield from cls._tile_psrs(op, df))
    File "/Users/qinxuye/Workspace/mars/mars/dataframe/sort/psrs.py", line 247, in _tile_psrs
      in_df, axis_chunk_shape, _, _ = yield from cls.preprocess(op, in_data=in_data)
    File "/Users/qinxuye/Workspace/mars/mars/tensor/base/psrs.py", line 63, in preprocess
      chunk_size = int(axis_shape / axis_chunk_shape)
  ZeroDivisionError: division by zero
    0%|                                                   | 0/100 [00:00<?, ?it/s]
  ---------------------------------------------------------------------------
  ZeroDivisionError                         Traceback (most recent call last)
  <ipython-input-17-2ab36a920a9b> in <module>
  ----> 1 df.sort_values(by=2).execute()
  
  ~/Workspace/mars/mars/core/entity/tileables.py in execute(self, session, **kw)
      460 
      461     def execute(self, session=None, **kw):
  --> 462         result = self.data.execute(session=session, **kw)
      463         if isinstance(result, TILEABLE_TYPE):
      464             return self
  
  ~/Workspace/mars/mars/core/entity/executable.py in execute(self, session, **kw)
       96 
       97         session = _get_session(self, session)
  ---> 98         return execute(self, session=session, **kw)
       99 
      100     def _check_session(self, session: SessionType, action: str):
  
  ~/Workspace/mars/mars/deploy/oscar/session.py in execute(tileable, session, wait, new_session_kwargs, show_progress, progress_update_interval, *tileables, **kwargs)
     1756         session = get_default_or_create(**(new_session_kwargs or dict()))
     1757     session = _ensure_sync(session)
  -> 1758     return session.execute(
     1759         tileable,
     1760         *tileables,
  
  ~/Workspace/mars/mars/deploy/oscar/session.py in execute(self, tileable, show_progress, *tileables, **kwargs)
     1556         fut = asyncio.run_coroutine_threadsafe(coro, self._loop)
     1557         try:
  -> 1558             execution_info: ExecutionInfo = fut.result(
     1559                 timeout=self._isolated_session.timeout
     1560             )
  
  ~/miniconda3/envs/mars3.8/lib/python3.8/concurrent/futures/_base.py in result(self, timeout)
      437                 raise CancelledError()
      438             elif self._state == FINISHED:
  --> 439                 return self.__get_result()
      440             else:
      441                 raise TimeoutError()
  
  ~/miniconda3/envs/mars3.8/lib/python3.8/concurrent/futures/_base.py in __get_result(self)
      386     def __get_result(self):
      387         if self._exception:
  --> 388             raise self._exception
      389         else:
      390             return self._result
  
  ~/Workspace/mars/mars/deploy/oscar/session.py in _execute(session, wait, show_progress, progress_update_interval, cancelled, *tileables, **kwargs)
     1707                 while not cancelled.is_set():
     1708                     try:
  -> 1709                         await asyncio.wait_for(
     1710                             asyncio.shield(execution_info), progress_update_interval
     1711                         )
  
  ~/miniconda3/envs/mars3.8/lib/python3.8/asyncio/tasks.py in wait_for(fut, timeout, loop)
      481 
      482         if fut.done():
  --> 483             return fut.result()
      484         else:
      485             fut.remove_done_callback(cb)
  
  ~/miniconda3/envs/mars3.8/lib/python3.8/asyncio/tasks.py in _wrap_awaitable(awaitable)
      682     that will later be wrapped in a Task by ensure_future().
      683     """
  --> 684     return (yield from awaitable.__await__())
      685 
      686 _wrap_awaitable._is_coroutine = _is_coroutine
  
  ~/Workspace/mars/mars/deploy/oscar/session.py in wait()
      100 
      101             async def wait():
  --> 102                 return await self._aio_task
      103 
      104             self._future_local.future = fut = asyncio.run_coroutine_threadsafe(
  
  ~/Workspace/mars/mars/deploy/oscar/session.py in _run_in_background(self, tileables, task_id, progress, profiling)
      894                     )
      895                 if task_result.error:
  --> 896                     raise task_result.error.with_traceback(task_result.traceback)
      897             if cancelled:
      898                 return
  
  ~/Workspace/mars/mars/services/task/supervisor/processor.py in inner(processor, *args, **kwargs)
       55     async def inner(processor: "TaskProcessor", *args, **kwargs):
       56         try:
  ---> 57             return await func(processor, *args, **kwargs)
       58         except:  # noqa: E722  # nosec  # pylint: disable=bare-except  # pragma: no cover
       59             if log_when_error:
  
  ~/Workspace/mars/mars/services/task/supervisor/processor.py in get_next_stage_processor(self)
      334 
      335         with Timer() as timer:
  --> 336             chunk_graph = await self._get_next_chunk_graph(self._chunk_graph_iter)
      337             if chunk_graph is None:
      338                 # tile finished
  
  ~/Workspace/mars/mars/services/task/supervisor/processor.py in _get_next_chunk_graph(self, chunk_graph_iter)
      264 
      265         fut = asyncio.to_thread(next_chunk_graph)
  --> 266         chunk_graph = await fut
      267         return chunk_graph
      268 
  
  ~/Workspace/mars/mars/lib/aio/_threads.py in to_thread(func, *args, **kwargs)
       34     ctx = contextvars.copy_context()
       35     func_call = functools.partial(ctx.run, func, *args, **kwargs)
  ---> 36     return await loop.run_in_executor(None, func_call)
  
  ~/miniconda3/envs/mars3.8/lib/python3.8/concurrent/futures/thread.py in run(self)
       55 
       56         try:
  ---> 57             result = self.fn(*self.args, **self.kwargs)
       58         except BaseException as exc:
       59             self.future.set_exception(exc)
  
  ~/Workspace/mars/mars/services/task/supervisor/processor.py in next_chunk_graph()
      259         def next_chunk_graph():
      260             try:
  --> 261                 return next(chunk_graph_iter)
      262             except StopIteration:
      263                 return
  
  ~/Workspace/mars/mars/services/task/supervisor/preprocessor.py in tile(self, tileable_graph)
      156         optimize = self._config.optimize_chunk_graph
      157         meta_updated = set()
  --> 158         for chunk_graph in chunk_graph_builder.build():
      159             # optimize chunk graph
      160             if optimize:
  
  ~/Workspace/mars/mars/core/graph/builder/chunk.py in build(self)
      270 
      271     def build(self) -> Generator[Union[TileableGraph, ChunkGraph], None, None]:
  --> 272         yield from self._build()
  
  ~/Workspace/mars/mars/core/graph/builder/chunk.py in _build(self)
      264             try:
      265                 with enter_mode(build=True, kernel=True):
  --> 266                     graph = next(tile_iterator)
      267                 yield graph
      268             except StopIteration:
  
  ~/Workspace/mars/mars/services/task/supervisor/preprocessor.py in __iter__(self)
       73     def __iter__(self):
       74         while self._tileable_handlers:
  ---> 75             to_update_tileables = self._iter()
       76             if not self.cancelled:
       77                 yield self._cur_chunk_graph
  
  ~/Workspace/mars/mars/core/graph/builder/chunk.py in _iter(self)
      196             next_tileable_handlers
      197         ):
  --> 198             self._tile(
      199                 chunk_graph,
      200                 tileable,
  
  ~/Workspace/mars/mars/core/graph/builder/chunk.py in _tile(self, chunk_graph, tileable, tile_handler, next_tileable_handlers, to_update_tileables, visited)
      111     ):
      112         try:
  --> 113             need_process = next(tile_handler)
      114             chunks = []
      115             if need_process is not None:
  
  ~/Workspace/mars/mars/core/graph/builder/chunk.py in _tile_handler(self, tileable)
       82         tiled_tileables = [self._get_data(t) for t in tiled_tileables]
       83         # start to tile
  ---> 84         tiled_tileables = yield from handler.tile(tiled_tileables)
       85         return tiled_tileables
       86 
  
  ~/Workspace/mars/mars/core/entity/tileables.py in tile(cls, tileables)
       77                 # they will be put into ChunkGraph and executed first.
       78                 # After execution, resume from the yield place.
  ---> 79                 tiled_result = yield from tile_handler(op)
       80             else:
       81                 # without iterative tiling
  
  ~/Workspace/mars/mars/dataframe/sort/core.py in tile(cls, op)
      179             return (yield from cls._tile_head(op))
      180         else:
  --> 181             return (yield from cls._tile(op))
  
  ~/Workspace/mars/mars/dataframe/sort/sort_values.py in _tile(cls, op)
       96     def _tile(cls, op):
       97         if op.inputs[0].ndim == 2:
  ---> 98             return (yield from cls._tile_dataframe(op))
       99         else:
      100             return (yield from cls._tile_series(op))
  
  ~/Workspace/mars/mars/dataframe/sort/sort_values.py in _tile_dataframe(cls, op)
       64                 raise NotImplementedError("Only support puts NaNs at the end.")
       65             # use parallel sorting by regular sampling
  ---> 66             return (yield from cls._tile_psrs(op, df))
       67 
       68     @classmethod
  
  ~/Workspace/mars/mars/dataframe/sort/psrs.py in _tile_psrs(cls, op, in_data)
      245     def _tile_psrs(cls, op, in_data):
      246         out = op.outputs[0]
  --> 247         in_df, axis_chunk_shape, _, _ = yield from cls.preprocess(op, in_data=in_data)
      248 
      249         # stage 1: local sort and regular samples collected
  
  ~/Workspace/mars/mars/tensor/base/psrs.py in preprocess(cls, op, in_data)
       61             ):
       62                 yield
  ---> 63             chunk_size = int(axis_shape / axis_chunk_shape)
       64             chunk_sizes = [chunk_size for _ in range(int(axis_shape // chunk_size))]
       65             if axis_shape % chunk_size > 0:
  
  ZeroDivisionError: division by zero
  ```
  