code: def swap_into_buffer(self, param, dest_buffer):
      assert (
          param.ds_tensor.status == PartitionedParamStatus.NOT_AVAILABLE
      ), f"param {param.ds_id} is already available or inflight"
  
      require_swap_buffer = not (
          dest_buffer.is_pinned()
          and self._is_io_aligned(dest_buffer.numel())
      )
  
      if require_swap_buffer:
          assert (
              len(self.available_buffer_ids) > 0
          ), f"No buffer available to swap param {param.ds_id}."
          (
              compute_buffers,
              swap_in_buffers,
          ) = self._allocate_and_return_buffers_for_swap_in([param])
          inflight_numel = compute_buffers[0].numel()
      else:
          swap_in_buffers = [dest_buffer]
          inflight_numel = dest_buffer.numel()
  
      swap_in_paths = self._get_swap_paths([param])
  
      swap_in_tensors(
          self.aio_read_handle, swap_in_buffers, swap_in_paths
      )
      self._update_inflight_swap_in(
          [param], swap_in_buffers, inflight_numel
      )
      self.synchronize_reads()
  
      if require_swap_buffer:
          dest_buffer.data.copy_(param.ds_tensor.data)
          # Release swap buffer memory assignment. Note, this will mark the parameter not available.
          self.remove_partition_and_release_buffers([param])
  
imports: import os
  import shutil
  from enum import Enum
  import torch
  from deepspeed import comm
  from deepspeed.ops.aio import AsyncIOBuilder
  from .constants import *
  from .utils import swap_in_tensors, swap_out_tensors, MIN_AIO_BYTES, AIO_ALIGNED_BYTES, print_object, SwapBufferPool
label_desc: Use image node_id 17 for calling the AsyncPartitionedParameterSwapper obj's underlying member method code with example usage: obj.swap_into_buffer(param, dest_buffer) without return types