code: def call(
      self,
      env,
      group,
      dst,
      dst_idx,
      src,
      src_idx,
      size,
      *,
      aligned_size=None,
  ):
      _check_include(env, "cg")
      _check_include(env, "cg_memcpy_async")
  
      dst = _Data.init(dst, env)
      src = _Data.init(src, env)
      for arr in (dst, src):
          if not isinstance(
              arr.ctype, (_cuda_types.CArray, _cuda_types.Ptr)
          ):
              raise TypeError("dst/src must be of array type.")
      dst = _compile._indexing(dst, dst_idx, env)
      src = _compile._indexing(src, src_idx, env)
  
      size = _compile._astype_scalar(
          # it's very unlikely that the size would exceed 2^32, so we just
          # pick uint32 for simplicity
          size,
          _cuda_types.uint32,
          "same_kind",
          env,
      )
      size = _Data.init(size, env)
      size_code = f"{size.code}"
  
      if aligned_size:
          if not isinstance(aligned_size, _Constant):
              raise ValueError(
                  "aligned_size must be a compile-time constant"
              )
          size_code = (
              f"cuda::aligned_size_t<{aligned_size.obj}>"
              f"({size_code})"
          )
      return _Data(
          f"cg::memcpy_async({group.code}, &({dst.code}), "
          f"&({src.code}), {size_code})",
          _cuda_types.void,
      )
  
imports: from cupy.cuda import runtime
  from cupyx.jit import _compile
  from cupyx.jit import _cuda_types
  from cupyx.jit._internal_types import BuiltinFunc
  from cupyx.jit._internal_types import Constant
  from cupyx.jit._internal_types import Data
  from cupyx.jit._internal_types import wraps_class_method
label_desc: Use image node_id 2 for calling the _MemcpySync obj's underlying member method code with example usage: obj.call(env, group, dst, dst_idx, src, src_idx, size) and returns: _Data