Add files using upload-large-folder tool

.gitattributes

@@ -1436,3 +1436,5 @@ vllm/lib/python3.10/site-packages/wandb/sdk/__pycache__/wandb_run.cpython-310.py
 parrot/lib/python3.10/site-packages/numpy/fft/_pocketfft_umath.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/numpy/_core/tests/__pycache__/test_numeric.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/numpy/lib/tests/__pycache__/test_function_base.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+vllm/lib/python3.10/site-packages/huggingface_hub/inference/_generated/__pycache__/_async_client.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+vllm/lib/python3.10/site-packages/huggingface_hub/inference/__pycache__/_client.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_dimI_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API int64_t sparse_dim_sparse(const at::Tensor & self);
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_acos_ops.h

@@ -0,0 +1,50 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _foreach_acos {
+  using schema = ::std::vector<at::Tensor> (at::TensorList);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_acos")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_acos(Tensor[] self) -> Tensor[]")
+  static ::std::vector<at::Tensor> call(at::TensorList self);
+  static ::std::vector<at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self);
+};
+
+struct TORCH_API _foreach_acos_ {
+  using schema = void (at::TensorList);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_acos_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_acos_(Tensor(a!)[] self) -> ()")
+  static void call(at::TensorList self);
+  static void redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self);
+};
+
+struct TORCH_API _foreach_acos_out {
+  using schema = void (at::TensorList, at::TensorList);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_acos")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_acos.out(Tensor[] self, *, Tensor(a!)[] out) -> ()")
+  static void call(at::TensorList self, at::TensorList out);
+  static void redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self, at::TensorList out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fused_sdp_choice.h

@@ -0,0 +1,30 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/_fused_sdp_choice_ops.h>
+
+namespace at {
+
+
+// aten::_fused_sdp_choice(Tensor query, Tensor key, Tensor value, Tensor? attn_mask=None, float dropout_p=0.0, bool is_causal=False, *, float? scale=None) -> int
+inline int64_t _fused_sdp_choice(const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const c10::optional<at::Tensor> & attn_mask={}, double dropout_p=0.0, bool is_causal=false, c10::optional<double> scale=c10::nullopt) {
+    return at::_ops::_fused_sdp_choice::call(query, key, value, attn_mask, dropout_p, is_causal, scale);
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_indices_copy_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API at::Tensor & _indices_copy_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & _indices_copy_outf(const at::Tensor & self, at::Tensor & out);
+
+} // namespace compositeexplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_local_scalar_dense_native.h

@@ -0,0 +1,22 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Scalar _local_scalar_dense_cpu(const at::Tensor & self);
+TORCH_API at::Scalar _local_scalar_dense_cuda(const at::Tensor & self);
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_sobol_engine_scramble.h

@@ -0,0 +1,30 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/_sobol_engine_scramble_ops.h>
+
+namespace at {
+
+
+// aten::_sobol_engine_scramble_(Tensor(a!) self, Tensor ltm, int dimension) -> Tensor(a!)
+inline at::Tensor & _sobol_engine_scramble_(at::Tensor & self, const at::Tensor & ltm, int64_t dimension) {
+    return at::_ops::_sobol_engine_scramble_::call(self, ltm, dimension);
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/and.h

@@ -0,0 +1,35 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/and_ops.h>
+
+namespace at {
+
+
+// aten::__and__.Scalar(Tensor self, Scalar other) -> Tensor
+inline at::Tensor __and__(const at::Tensor & self, const at::Scalar & other) {
+    return at::_ops::__and___Scalar::call(self, other);
+}
+
+// aten::__and__.Tensor(Tensor self, Tensor other) -> Tensor
+inline at::Tensor __and__(const at::Tensor & self, const at::Tensor & other) {
+    return at::_ops::__and___Tensor::call(self, other);
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/binary_cross_entropy_cuda_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API at::Tensor binary_cross_entropy(const at::Tensor & self, const at::Tensor & target, const c10::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean);
+TORCH_API at::Tensor & binary_cross_entropy_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & target, const c10::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean);
+TORCH_API at::Tensor & binary_cross_entropy_outf(const at::Tensor & self, const at::Tensor & target, const c10::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & out);
+
+} // namespace cuda
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/bitwise_xor_ops.h

@@ -0,0 +1,105 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API bitwise_xor_Tensor_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_xor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_xor.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+};
+
+struct TORCH_API bitwise_xor_Scalar_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_xor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_xor.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Scalar & other, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other, at::Tensor & out);
+};
+
+struct TORCH_API bitwise_xor_Scalar {
+  using schema = at::Tensor (const at::Tensor &, const at::Scalar &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_xor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_xor.Scalar(Tensor self, Scalar other) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Scalar & other);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other);
+};
+
+struct TORCH_API bitwise_xor_Scalar_Tensor {
+  using schema = at::Tensor (const at::Scalar &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_xor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_xor.Scalar_Tensor(Scalar self, Tensor other) -> Tensor")
+  static at::Tensor call(const at::Scalar & self, const at::Tensor & other);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & self, const at::Tensor & other);
+};
+
+struct TORCH_API bitwise_xor_Tensor {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_xor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_xor.Tensor(Tensor self, Tensor other) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Tensor & other);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other);
+};
+
+struct TORCH_API bitwise_xor__Scalar {
+  using schema = at::Tensor & (at::Tensor &, const at::Scalar &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_xor_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_xor_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Scalar & other);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Scalar & other);
+};
+
+struct TORCH_API bitwise_xor__Tensor {
+  using schema = at::Tensor & (at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_xor_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_xor_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Tensor & other);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & other);
+};
+
+struct TORCH_API bitwise_xor_Scalar_Tensor_out {
+  using schema = at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_xor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_Tensor_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_xor.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Scalar & self, const at::Tensor & other, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & self, const at::Tensor & other, at::Tensor & out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/div_ops.h

@@ -0,0 +1,149 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API div_Tensor {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::div")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "div.Tensor(Tensor self, Tensor other) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Tensor & other);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other);
+};
+
+struct TORCH_API div__Tensor {
+  using schema = at::Tensor & (at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::div_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "div_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Tensor & other);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & other);
+};
+
+struct TORCH_API div_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::div")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "div.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+};
+
+struct TORCH_API div_Tensor_mode {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional<c10::string_view>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::div")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_mode")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "div.Tensor_mode(Tensor self, Tensor other, *, str? rounding_mode) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Tensor & other, c10::optional<c10::string_view> rounding_mode);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other, c10::optional<c10::string_view> rounding_mode);
+};
+
+struct TORCH_API div__Tensor_mode {
+  using schema = at::Tensor & (at::Tensor &, const at::Tensor &, c10::optional<c10::string_view>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::div_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_mode")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "div_.Tensor_mode(Tensor(a!) self, Tensor other, *, str? rounding_mode) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Tensor & other, c10::optional<c10::string_view> rounding_mode);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & other, c10::optional<c10::string_view> rounding_mode);
+};
+
+struct TORCH_API div_out_mode {
+  using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, c10::optional<c10::string_view>, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::div")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out_mode")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "div.out_mode(Tensor self, Tensor other, *, str? rounding_mode, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Tensor & other, c10::optional<c10::string_view> rounding_mode, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other, c10::optional<c10::string_view> rounding_mode, at::Tensor & out);
+};
+
+struct TORCH_API div_Scalar {
+  using schema = at::Tensor (const at::Tensor &, const at::Scalar &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::div")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "div.Scalar(Tensor self, Scalar other) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Scalar & other);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other);
+};
+
+struct TORCH_API div__Scalar {
+  using schema = at::Tensor & (at::Tensor &, const at::Scalar &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::div_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "div_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Scalar & other);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Scalar & other);
+};
+
+struct TORCH_API div_Scalar_mode {
+  using schema = at::Tensor (const at::Tensor &, const at::Scalar &, c10::optional<c10::string_view>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::div")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_mode")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "div.Scalar_mode(Tensor self, Scalar other, *, str? rounding_mode) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Scalar & other, c10::optional<c10::string_view> rounding_mode);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other, c10::optional<c10::string_view> rounding_mode);
+};
+
+struct TORCH_API div__Scalar_mode {
+  using schema = at::Tensor & (at::Tensor &, const at::Scalar &, c10::optional<c10::string_view>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::div_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_mode")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "div_.Scalar_mode(Tensor(a!) self, Scalar other, *, str? rounding_mode) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Scalar & other, c10::optional<c10::string_view> rounding_mode);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Scalar & other, c10::optional<c10::string_view> rounding_mode);
+};
+
+struct TORCH_API div_Scalar_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::div")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "div.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Scalar & other, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other, at::Tensor & out);
+};
+
+struct TORCH_API div_Scalar_mode_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Scalar &, c10::optional<c10::string_view>, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::div")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_mode_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "div.Scalar_mode_out(Tensor self, Scalar other, *, str? rounding_mode, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Scalar & other, c10::optional<c10::string_view> rounding_mode, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other, c10::optional<c10::string_view> rounding_mode, at::Tensor & out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/dropout_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API dropout {
+  using schema = at::Tensor (const at::Tensor &, double, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::dropout")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "dropout(Tensor input, float p, bool train) -> Tensor")
+  static at::Tensor call(const at::Tensor & input, double p, bool train);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, double p, bool train);
+};
+
+struct TORCH_API dropout_ {
+  using schema = at::Tensor & (at::Tensor &, double, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::dropout_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "dropout_(Tensor(a!) self, float p, bool train) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, double p, bool train);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, double p, bool train);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/embedding_sparse_backward_ops.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API embedding_sparse_backward {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::embedding_sparse_backward")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "embedding_sparse_backward(Tensor grad, Tensor indices, int num_weights, int padding_idx, bool scale_grad_by_freq) -> Tensor")
+  static at::Tensor call(const at::Tensor & grad, const at::Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad, const at::Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/i0_meta.h

@@ -0,0 +1,27 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeMetaFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/TensorIterator.h>
+#include <ATen/TensorMeta.h>
+#include <tuple>
+#include <vector>
+
+namespace at {
+namespace meta {
+
+struct TORCH_API structured_i0 : public TensorIteratorBase {
+    
+    
+    void meta(const at::Tensor & self);
+};
+
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/log2_ops.h

@@ -0,0 +1,50 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API log2 {
+  using schema = at::Tensor (const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::log2")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "log2(Tensor self) -> Tensor")
+  static at::Tensor call(const at::Tensor & self);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self);
+};
+
+struct TORCH_API log2_ {
+  using schema = at::Tensor & (at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::log2_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "log2_(Tensor(a!) self) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self);
+};
+
+struct TORCH_API log2_out {
+  using schema = at::Tensor & (const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::log2")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "log2.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/log_native.h

@@ -0,0 +1,23 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+#include <ATen/ops/log_meta.h>
+
+namespace at {
+namespace native {
+struct TORCH_API structured_log_out : public at::meta::structured_log {
+void impl(const at::Tensor & self, const at::Tensor & out);
+};
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/min_meta_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace meta {
+
+TORCH_API ::std::tuple<at::Tensor,at::Tensor> min(const at::Tensor & self, int64_t dim, bool keepdim=false);
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> min_out(at::Tensor & min, at::Tensor & min_indices, const at::Tensor & self, int64_t dim, bool keepdim=false);
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> min_outf(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & min, at::Tensor & min_indices);
+
+} // namespace meta
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/min_ops.h

@@ -0,0 +1,105 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API min_dim {
+  using schema = ::std::tuple<at::Tensor,at::Tensor> (const at::Tensor &, int64_t, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::min")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "dim")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "min.dim(Tensor self, int dim, bool keepdim=False) -> (Tensor values, Tensor indices)")
+  static ::std::tuple<at::Tensor,at::Tensor> call(const at::Tensor & self, int64_t dim, bool keepdim);
+  static ::std::tuple<at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t dim, bool keepdim);
+};
+
+struct TORCH_API min_dim_min {
+  using schema = ::std::tuple<at::Tensor &,at::Tensor &> (const at::Tensor &, int64_t, bool, at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::min")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "dim_min")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "min.dim_min(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) min, Tensor(b!) min_indices) -> (Tensor(a!) values, Tensor(b!) indices)")
+  static ::std::tuple<at::Tensor &,at::Tensor &> call(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & min, at::Tensor & min_indices);
+  static ::std::tuple<at::Tensor &,at::Tensor &> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & min, at::Tensor & min_indices);
+};
+
+struct TORCH_API min_names_dim {
+  using schema = ::std::tuple<at::Tensor,at::Tensor> (const at::Tensor &, at::Dimname, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::min")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "names_dim")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "min.names_dim(Tensor self, Dimname dim, bool keepdim=False) -> (Tensor values, Tensor indices)")
+  static ::std::tuple<at::Tensor,at::Tensor> call(const at::Tensor & self, at::Dimname dim, bool keepdim);
+  static ::std::tuple<at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Dimname dim, bool keepdim);
+};
+
+struct TORCH_API min_names_dim_min {
+  using schema = ::std::tuple<at::Tensor &,at::Tensor &> (const at::Tensor &, at::Dimname, bool, at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::min")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "names_dim_min")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "min.names_dim_min(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) min, Tensor(b!) min_indices) -> (Tensor(a!) values, Tensor(b!) indices)")
+  static ::std::tuple<at::Tensor &,at::Tensor &> call(const at::Tensor & self, at::Dimname dim, bool keepdim, at::Tensor & min, at::Tensor & min_indices);
+  static ::std::tuple<at::Tensor &,at::Tensor &> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Dimname dim, bool keepdim, at::Tensor & min, at::Tensor & min_indices);
+};
+
+struct TORCH_API min {
+  using schema = at::Tensor (const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::min")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "min(Tensor self) -> Tensor")
+  static at::Tensor call(const at::Tensor & self);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self);
+};
+
+struct TORCH_API min_unary_out {
+  using schema = at::Tensor & (const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::min")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "unary_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "min.unary_out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out);
+};
+
+struct TORCH_API min_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::min")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "min.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+};
+
+struct TORCH_API min_other {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::min")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "other")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "min.other(Tensor self, Tensor other) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Tensor & other);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/repeat_native.h

@@ -0,0 +1,22 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor repeat(const at::Tensor & self, at::IntArrayRef repeats);
+TORCH_API at::Tensor & repeat_out_symint(const at::Tensor & self, c10::SymIntArrayRef repeats, at::Tensor & out);
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_erf_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API at::Tensor special_erf(const at::Tensor & self);
+TORCH_API at::Tensor & special_erf_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & special_erf_outf(const at::Tensor & self, at::Tensor & out);
+
+} // namespace compositeimplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/tril_meta.h

@@ -0,0 +1,27 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeMetaFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/TensorIterator.h>
+#include <ATen/TensorMeta.h>
+#include <tuple>
+#include <vector>
+
+namespace at {
+namespace meta {
+
+struct TORCH_API structured_tril : public at::impl::MetaBase {
+    
+    
+    void meta(const at::Tensor & self, int64_t diagonal);
+};
+
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/triplet_margin_loss_ops.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API triplet_margin_loss {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, double, double, double, bool, int64_t);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::triplet_margin_loss")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "triplet_margin_loss(Tensor anchor, Tensor positive, Tensor negative, float margin=1.0, float p=2, float eps=1e-06, bool swap=False, int reduction=Mean) -> Tensor")
+  static at::Tensor call(const at::Tensor & anchor, const at::Tensor & positive, const at::Tensor & negative, double margin, double p, double eps, bool swap, int64_t reduction);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & anchor, const at::Tensor & positive, const at::Tensor & negative, double margin, double p, double eps, bool swap, int64_t reduction);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/triu_indices.h

@@ -0,0 +1,43 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/triu_indices_ops.h>
+
+namespace at {
+
+
+// aten::triu_indices(int row, int col, int offset=0, *, ScalarType? dtype=long, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
+inline at::Tensor triu_indices(int64_t row, int64_t col, int64_t offset=0, at::TensorOptions options=at::kLong) {
+    return at::_ops::triu_indices::call(row, col, offset, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
+}
+// aten::triu_indices(int row, int col, int offset=0, *, ScalarType? dtype=long, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
+inline at::Tensor triu_indices(int64_t row, int64_t col, int64_t offset, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory) {
+    return at::_ops::triu_indices::call(row, col, offset, dtype, layout, device, pin_memory);
+}
+
+// aten::triu_indices.out(int row, int col, int offset=0, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & triu_indices_out(at::Tensor & out, int64_t row, int64_t col, int64_t offset=0) {
+    return at::_ops::triu_indices_out::call(row, col, offset, out);
+}
+// aten::triu_indices.out(int row, int col, int offset=0, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & triu_indices_outf(int64_t row, int64_t col, int64_t offset, at::Tensor & out) {
+    return at::_ops::triu_indices_out::call(row, col, offset, out);
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/upsample_nearest1d_backward_cuda_dispatch.h

@@ -0,0 +1,28 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API at::Tensor upsample_nearest1d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, c10::optional<double> scales=c10::nullopt);
+TORCH_API at::Tensor upsample_nearest1d_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, c10::optional<double> scales=c10::nullopt);
+TORCH_API at::Tensor & upsample_nearest1d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, c10::optional<double> scales=c10::nullopt);
+TORCH_API at::Tensor & upsample_nearest1d_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, c10::optional<double> scales, at::Tensor & grad_input);
+TORCH_API at::Tensor & upsample_nearest1d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, c10::optional<double> scales=c10::nullopt);
+TORCH_API at::Tensor & upsample_nearest1d_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, c10::optional<double> scales, at::Tensor & grad_input);
+
+} // namespace cuda
+} // namespace at

vllm/lib/python3.10/site-packages/cupyx/distributed/array/_array.py

@@ -0,0 +1,899 @@
+from itertools import chain
+from typing import Any, Callable, Iterable, Optional
+
+import numpy
+from numpy.typing import ArrayLike
+from numpy.typing import DTypeLike
+
+import cupy
+from cupy._core.core import ndarray
+import cupy._creation.from_data as _creation_from_data
+import cupy._core._routines_math as _math
+import cupy._core._routines_statistics as _statistics
+from cupy.cuda.device import Device
+from cupy.cuda.stream import Stream
+from cupy.cuda.stream import get_current_stream
+
+from cupyx.distributed.array import _chunk
+from cupyx.distributed.array._chunk import _Chunk
+from cupyx.distributed.array import _data_transfer
+from cupyx.distributed.array._data_transfer import _Communicator
+from cupyx.distributed.array import _elementwise
+from cupyx.distributed.array import _index_arith
+from cupyx.distributed.array import _modes
+from cupyx.distributed.array import _reduction
+from cupyx.distributed.array import _linalg
+
+
+class _MultiDeviceDummyMemory(cupy.cuda.memory.Memory):
+    pass
+
+
+class _MultiDeviceDummyPointer(cupy.cuda.memory.MemoryPointer):
+    @property
+    def device(self) -> Device:
+        # This override is needed to assign an invalid device id
+        # Since the array is not residing in a single device now
+        return Device(-1)
+
+
+def _make_chunk_async(src_dev, dst_dev, idx, src_array, comms):
+    src_stream = get_current_stream(src_dev)
+    with src_array.device:
+        src_array = _creation_from_data.ascontiguousarray(src_array)
+        src_data = _data_transfer._AsyncData(
+            src_array, src_stream.record(), prevent_gc=src_array)
+    with Device(dst_dev):
+        dst_stream = get_current_stream()
+        copied = _data_transfer._transfer(
+            comms[src_dev], src_stream, src_data,
+            comms[dst_dev], dst_stream, dst_dev)
+        return _Chunk(copied.array, copied.ready, idx,
+                      prevent_gc=src_data)
+
+
+def _make_chunk_sync(src_dev, dst_dev, idx, src_array, comms):
+    with Device(dst_dev):
+        stream = get_current_stream()
+        copied = _creation_from_data.array(src_array)
+        return _Chunk(copied, stream.record(), idx, prevent_gc=src_array)
+
+
+class DistributedArray(ndarray):
+    """
+    __init__(self, shape, dtype, chunks_map, mode=REPLICA, comms=None)
+
+    Multi-dimensional array distributed across multiple CUDA devices.
+
+    This class implements some elementary operations that :class:`cupy.ndarray`
+    provides. The array content is split into chunks, contiguous arrays
+    corresponding to slices of the original array. Note that one device can
+    hold multiple chunks.
+
+    This direct constructor is designed for internal calls. Users should create
+    distributed arrays using :func:`distributed_array`.
+
+    Args:
+        shape (tuple of ints): Shape of created array.
+        dtype (dtype_like): Any object that can be interpreted as a numpy data
+            type.
+        chunks_map (dict from int to list of chunks): Lists of chunk objects
+            associated with each device.
+        mode (mode object, optional): Mode that determines how overlaps
+            of the chunks are interpreted. Defaults to
+            ``cupyx.distributed.array.REPLICA``.
+        comms (optional): Communicator objects which a distributed array
+            hold internally. Sharing them with other distributed arrays can
+            save time because their initialization is a costly operation.
+
+    .. seealso::
+            :attr:`DistributedArray.mode` for details about modes.
+    """
+
+    _chunks_map: dict[int, list[_Chunk]]
+    _mode: _modes.Mode
+    _streams: dict[int, Stream]
+    _comms: dict[int, _Communicator]
+
+    def __new__(
+        cls, shape: tuple[int, ...], dtype: DTypeLike,
+        chunks_map: dict[int, list[_Chunk]],
+        mode: _modes.Mode = _modes.REPLICA,
+        comms: Optional[dict[int, _Communicator]] = None,
+    ) -> 'DistributedArray':
+        mem = _MultiDeviceDummyMemory(0)
+        memptr = _MultiDeviceDummyPointer(mem, 0)
+        obj = super().__new__(cls, shape, dtype, memptr=memptr)
+        obj._chunks_map = chunks_map
+
+        obj._mode = mode
+
+        obj._streams = {}
+        obj._comms = comms if comms is not None else {}
+
+        return obj
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+    def __array_finalize__(self, obj):
+        if obj is not None:
+            raise RuntimeError(
+                'Distributed array can only be instantiated by an explicit'
+                'constructor call')
+
+    @property
+    def mode(self) -> _modes.Mode:
+        """Describe how overlaps of the chunks are interpreted.
+
+        In the replica mode, chunks are guaranteed to have identical values on
+        their overlapping segments. In other modes, they are not necessarily
+        identical and represent the original data as their max, sum, etc.
+
+        :class:`DistributedArray` currently supports
+        ``cupyx.distributed.array.REPLICA``, ``cupyx.distributed.array.MIN``,
+        ``cupyx.distributed.array.MAX``, ``cupyx.distributed.array.SUM``,
+        ``cupyx.distributed.array.PROD`` modes.
+
+        Many operations on distributed arrays including :class:`cupy.ufunc`
+        and :func:`~cupyx.distributed.array.matmul` involve changing their mode
+        beforehand. These mode conversions are done automatically, so in most
+        cases users do not have to manage modes manually.
+
+        Example:
+            >>> A = distributed_array(
+            ...     cupy.arange(6).reshape(2, 3),
+            ...     make_2d_index_map([0, 2], [0, 1, 3],
+            ...                       [[{0}, {1, 2}]]))
+            >>> B = distributed_array(
+            ...     cupy.arange(12).reshape(3, 4),
+            ...     make_2d_index_map([0, 1, 3], [0, 2, 4],
+            ...                       [[{0}, {0}],
+            ...                        [{1}, {2}]]))
+            >>> C = A @ B
+            >>> C
+            array([[20, 23, 26, 29],
+                   [56, 68, 80, 92]])
+            >>> C.mode
+            'sum'
+            >>> C.all_chunks()
+            {0: [array([[0, 0],
+                        [0, 3]]),     # left half
+                 array([[0, 0],
+                        [6, 9]])],    # right half
+             1: [array([[20, 23],
+                        [56, 65]])],  # left half
+             2: [array([[26, 29],
+                        [74, 83]])]}  # right half
+            >>> C_replica = C.change_mode('replica')
+            >>> C_replica.mode
+            'replica'
+            >>> C_replica.all_chunks()
+            {0: [array([[20, 23],
+                        [56, 68]]),   # left half
+                 array([[26, 29],
+                        [80, 92]])],  # right half
+             1: [array([[20, 23],
+                        [56, 68]])],  # left half
+             2: [array([[26, 29],
+                        [80, 92]])]}  # right half
+        """
+        return self._mode
+
+    @property
+    def devices(self) -> Iterable[int]:
+        """A collection of device IDs holding part of the data."""
+        return self._chunks_map.keys()
+
+    @property
+    def index_map(self) -> dict[int, list[tuple[slice, ...]]]:
+        """Indices for the chunks that devices with designated IDs own."""
+        return {dev: [chunk.index for chunk in chunks]
+                for dev, chunks in self._chunks_map.items()}
+
+    def all_chunks(self) -> dict[int, list[ndarray]]:
+        """Return the chunks with all buffered data flushed.
+
+        Buffered data are created in situations such as resharding and mode
+        changing.
+        """
+        chunks_map: dict[int, list[ndarray]] = {}
+        for dev, chunks in self._chunks_map.items():
+            chunks_map[dev] = []
+            for chunk in chunks:
+                chunk.flush(self._mode)
+                chunks_map[dev].append(chunk.array)
+        return chunks_map
+
+    def _prepare_comms_and_streams(self, devices: Iterable[int]) -> None:
+        # Ensure communicators and streams are prepared for communication
+        # between `devices` and the devices currently owning chunks
+        devices = self._chunks_map.keys() | devices
+
+        if not devices.issubset(self._comms.keys()):
+            self._comms = _data_transfer._create_communicators(devices)
+
+        for dev in devices - self._streams.keys():
+            with Device(dev):
+                self._streams[dev] = Stream()
+
+    def __cupy_override_elementwise_kernel__(self, kernel, *args, **kwargs):
+        # This method is called from cupy.ufunc and cupy.ElementwiseKernel
+        # to dispatch elementwise operations
+        return _elementwise._execute(kernel, args, kwargs)
+
+    def __cupy_override_reduction_kernel__(
+            self, kernel, axis, dtype, out, keepdims) -> Any:
+        # This method is called from _SimpleReductionKernel and elementary
+        # reduction methods of ndarray to dispatch reduction operations
+        # TODO: Support user-defined ReductionKernel
+        if axis is None:
+            raise RuntimeError('axis must be specified')
+        if out is not None:
+            raise RuntimeError('Argument `out` is not supported')
+        if keepdims:
+            raise RuntimeError('Argument `keepdims` is not supported')
+
+        return _reduction._execute(self, kernel, axis, dtype)
+
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        if ufunc.__name__ == 'matmul' and method == '__call__':
+            return _linalg.matmul(*inputs, **kwargs)
+        return NotImplemented
+
+    def __matmul__(x, y):
+        if isinstance(y, DistributedArray):
+            return _linalg.matmul(x, y)
+        else:
+            return NotImplemented
+
+    def _copy_chunks_map_in_replica_mode(self) -> dict[int, list[_Chunk]]:
+        # Return a copy of self.chunks_map in the replica mode
+        chunks_map = {}
+        for dev, chunks in self._chunks_map.items():
+            chunks_map[dev] = [chunk.copy() for chunk in chunks]
+
+        if self._mode is not _modes.REPLICA:
+            self._prepare_comms_and_streams(self._chunks_map.keys())
+            _chunk._all_reduce_intersections(
+                self._mode, self.shape, chunks_map, self._comms, self._streams)
+
+        return chunks_map
+
+    def _copy_chunks_map_in_op_mode(
+            self, op_mode: _modes._OpMode) -> dict[int, list[_Chunk]]:
+        # Return a copy of self.chunks_map in the given op mode
+        chunks_map = self._copy_chunks_map_in_replica_mode()
+
+        for chunk in chain.from_iterable(chunks_map.values()):
+            chunk.flush(_modes.REPLICA)
+
+        chunks_list = list(chain.from_iterable(chunks_map.values()))
+        identity = op_mode.identity_of(self.dtype)
+
+        # TODO: Fair distribution of work
+        # In the current implementation, devices that appear earlier have to
+        # execute set_identity_on_intersection repeatedly, whereas the last
+        # device has no work to do
+        for i in range(len(chunks_list)):
+            a_chunk = chunks_list[i]
+            for j in range(i + 1, len(chunks_list)):
+                b_chunk = chunks_list[j]
+                a_chunk.set_identity_on_intersection(
+                    b_chunk.index, self.shape, identity)
+
+        return chunks_map
+
+    def _to_op_mode(self, op_mode: _modes.Mode) -> 'DistributedArray':
+        # Return a view or a copy of the chunks_map in the given mode
+        if self._mode is op_mode:
+            return self
+
+        if len(self._chunks_map) == 1:
+            chunks, = self._chunks_map.values()
+            if len(chunks) == 1:
+                chunks[0].flush(self._mode)
+                return DistributedArray(
+                    self.shape, self.dtype, self._chunks_map,
+                    op_mode, self._comms)
+        if op_mode is _modes.REPLICA:
+            chunks_map = self._copy_chunks_map_in_replica_mode()
+        else:
+            assert op_mode is not None
+            chunks_map = self._copy_chunks_map_in_op_mode(op_mode)
+        return DistributedArray(
+            self.shape, self.dtype, chunks_map, op_mode, self._comms)
+
+    def change_mode(self, mode: _modes.Mode) -> 'DistributedArray':
+        """Return a view or a copy in the given mode.
+
+        Args:
+            mode (mode Object): How overlaps of
+                the chunks are interpreted.
+
+        .. seealso::
+                :attr:`DistributedArray.mode` for details about modes.
+        """
+        return self._to_op_mode(mode)
+
+    def reshard(self, index_map: dict[int, Any]) -> 'DistributedArray':
+        """Return a view or a copy having the given index_map.
+
+        Data transfers across devices are done on separate streams created
+        internally. To make them asynchronous, transferred data is buffered and
+        reflected to the chunks when necessary.
+
+        Args:
+            index_map (dict from int to array indices): Indices for the chunks
+                that devices with designated IDs own. The current index_map of
+                a distributed array can be obtained from
+                :attr:`DistributedArray.index_map`.
+        """
+        new_index_map = _index_arith._normalize_index_map(
+            self.shape, index_map)
+        if new_index_map == self.index_map:
+            return self
+
+        old_chunks_map = self._chunks_map
+        new_chunks_map: dict[int, list[_Chunk]] = {}
+
+        # Set up new_chunks_map compatible with new_index_map
+        # as placeholders of chunks
+        for dev, idxs in new_index_map.items():
+            new_chunks_map[dev] = []
+
+            for idx in idxs:
+                with Device(dev):
+                    dst_shape = _index_arith._shape_after_indexing(
+                        self.shape, idx)
+                    new_chunk = _Chunk.create_placeholder(dst_shape, dev, idx)
+                    new_chunks_map[dev].append(new_chunk)
+
+        self._prepare_comms_and_streams(index_map.keys())
+
+        # Data transfer from old chunks to new chunks
+        # TODO: Reorder transfers to minimize latency
+
+        # The current implementation transfers the same data multiple times
+        # where chunks overlap. This is particularly problematic when matrix
+        # multiplication is involved, where one block tends to be shared
+        # between multiple devices
+        # TODO: Avoid duplicate data transfers
+        for src_chunk in chain.from_iterable(old_chunks_map.values()):
+            src_chunk.flush(self._mode)
+
+            if self._mode is not _modes.REPLICA:
+                src_chunk = src_chunk.copy()
+
+            for dst_chunk in chain.from_iterable(new_chunks_map.values()):
+                src_chunk.apply_to(
+                    dst_chunk, self._mode, self.shape,
+                    self._comms, self._streams)
+
+        return DistributedArray(
+            self.shape, self.dtype, new_chunks_map, self._mode, self._comms)
+
+    def get(
+        self, stream=None, order='C', out=None, blocking=True
+    ) -> numpy.ndarray:
+        """Return a copy of the array on the host memory."""
+        if stream is not None:
+            raise RuntimeError('Argument `stream` not supported')
+        if order != 'C':
+            raise RuntimeError('Argument `order` not supported')
+        if out is not None:
+            raise RuntimeError('Argument `out` not supported')
+
+        for chunk in chain.from_iterable(self._chunks_map.values()):
+            chunk.flush(self._mode)
+
+        if self._mode is _modes.REPLICA:
+            np_array = numpy.empty(self.shape, dtype=self.dtype)
+        else:
+            identity = self._mode.identity_of(self.dtype)
+            np_array = numpy.full(self.shape, identity, self.dtype)
+
+        # We avoid 0D array because we expect data[idx] to return a view
+        np_array = numpy.atleast_1d(np_array)
+
+        for chunk in chain.from_iterable(self._chunks_map.values()):
+            chunk.ready.synchronize()
+            idx = chunk.index
+            if self._mode is _modes.REPLICA:
+                np_array[idx] = cupy.asnumpy(chunk.array)
+            else:
+                self._mode.numpy_func(
+                    np_array[idx], cupy.asnumpy(chunk.array), np_array[idx])
+
+        # Undo numpy.atleast_1d
+        return np_array.reshape(self.shape)
+
+    # -----------------------------------------------------
+    # Overriding unsupported methods inherited from ndarray
+    # -----------------------------------------------------
+
+    def __getitem__(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support __getitem__.')
+
+    def __setitem__(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support __setitem__.')
+
+    def __len__(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support __len__.')
+
+    def __iter__(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support __iter__.')
+
+    def __copy__(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support __copy__.')
+
+    def all(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support all.')
+
+    def any(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support any.')
+
+    def argmax(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support argmax.')
+
+    def argmin(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support argmin.')
+
+    def argpartition(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support argpartition.')
+
+    def argsort(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support argsort.')
+
+    def astype(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support astype.')
+
+    def choose(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support choose.')
+
+    def clip(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support clip.')
+
+    def compress(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support compress.')
+
+    def copy(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support copy.')
+
+    def cumprod(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support cumprod.')
+
+    def cumsum(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support cumsum.')
+
+    def diagonal(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support diagonal.')
+
+    def dot(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support dot.')
+
+    def dump(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support dump.')
+
+    def dumps(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support dumps.')
+
+    def fill(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support fill.')
+
+    def flatten(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support flatten.')
+
+    def item(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support item.')
+
+    def max(self, axis=None, out=None, keepdims=False):
+        """Return the maximum along a given axis.
+
+        .. note::
+
+            Currently, it only supports non-``None`` values for ``axis`` and
+            the default values for ``out`` and ``keepdims``.
+
+        .. seealso::
+           :meth:`cupy.ndarray.max`, :meth:`numpy.ndarray.max`
+        """
+        return self.__cupy_override_reduction_kernel__(
+            _statistics.amax, axis, None, out, keepdims)
+
+    def mean(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support mean.')
+
+    def min(self, axis=None, out=None, keepdims=False):
+        """Return the minimum along a given axis.
+
+        .. note::
+
+            Currently, it only supports non-``None`` values for ``axis`` and
+            the default values for ``out`` and ``keepdims``.
+
+        .. seealso::
+           :meth:`cupy.ndarray.min`, :meth:`numpy.ndarray.min`
+        """
+        return self.__cupy_override_reduction_kernel__(
+            _statistics.amin, axis, None, out, keepdims)
+
+    def nonzero(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support nonzero.')
+
+    def partition(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support partition.')
+
+    def prod(self, axis=None, dtype=None, out=None, keepdims=None):
+        """Return the minimum along a given axis.
+
+        .. note::
+
+            Currently, it only supports non-``None`` values for ``axis`` and
+            the default values for ``out`` and ``keepdims``.
+
+        .. seealso::
+           :meth:`cupy.ndarray.prod`, :meth:`numpy.ndarray.prod`
+        """
+        if dtype is None:
+            return self.__cupy_override_reduction_kernel__(
+                _math.prod_auto_dtype, axis, dtype, out, keepdims)
+        else:
+            return self.__cupy_override_reduction_kernel__(
+                _math.prod_keep_dtype, axis, dtype, out, keepdims)
+
+    def ptp(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support ptp.')
+
+    def put(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support put.')
+
+    def ravel(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support ravel.')
+
+    def reduced_view(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support reduced_view.')
+
+    def repeat(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support repeat.')
+
+    def reshape(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support reshape.')
+
+    def round(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support round.')
+
+    def scatter_add(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support scatter_add.')
+
+    def scatter_max(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support scatter_max.')
+
+    def scatter_min(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support scatter_min.')
+
+    def searchsorted(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support searchsorted.')
+
+    def set(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support set.')
+
+    def sort(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support sort.')
+
+    def squeeze(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support squeeze.')
+
+    def std(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support std.')
+
+    def sum(self, axis=None, dtype=None, out=None, keepdims=False):
+        """Return the minimum along a given axis.
+
+        .. note::
+
+            Currently, it only supports non-``None`` values for ``axis`` and
+            the default values for ``out`` and ``keepdims``.
+
+        .. seealso::
+           :meth:`cupy.ndarray.sum`, :meth:`numpy.ndarray.sum`
+        """
+        if dtype is None:
+            return self.__cupy_override_reduction_kernel__(
+                _math.sum_auto_dtype, axis, dtype, out, keepdims)
+        else:
+            return self.__cupy_override_reduction_kernel__(
+                _math.sum_keep_dtype, axis, dtype, out, keepdims)
+
+    def swapaxes(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support swapaxes.')
+
+    def take(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support take.')
+
+    def toDlpack(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support toDlpack.')
+
+    def tobytes(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support tobytes.')
+
+    def tofile(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support tofile.')
+
+    def tolist(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support tolist.')
+
+    def trace(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support trace.')
+
+    def transpose(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support transpose.')
+
+    def var(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support var.')
+
+    def view(self, *args, **kwargs):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support view.')
+
+    @property
+    def T(self):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support T.')
+
+    @property
+    def base(self):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support base.')
+
+    @property
+    def cstruct(self):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support cstruct.')
+
+    @property
+    def data(self):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support data.')
+
+    @property
+    def device(self):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support device.')
+
+    @property
+    def flags(self):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support flags.')
+
+    @property
+    def flat(self):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support flat.')
+
+    @property
+    def imag(self):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support imag.')
+
+    @property
+    def real(self):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support real.')
+
+    @property
+    def shape(self):
+        """Tuple of array dimensions.
+
+        Assignment to this property is currently not supported.
+
+        .. seealso: :attr:`cupy.ndarray.shape`, :attr:`numpy.ndarray.shape`
+
+        """
+        return super().shape
+
+    @shape.setter
+    def shape(self, newshape):
+        raise NotImplementedError(
+            'DistributedArray currently does not support assignment to shape.')
+
+    @property
+    def strides(self):
+        """Not supported."""
+        raise NotImplementedError(
+            'DistributedArray currently does not support strides.')
+
+
+def distributed_array(
+    array: ArrayLike,
+    index_map: dict[int, Any],
+    mode: _modes.Mode = _modes.REPLICA,
+) -> DistributedArray:
+    """Creates a distributed array from the given data.
+
+    This function does not check if all elements of the given array are stored
+    in some of the chunks.
+
+    Args:
+        array (array_like): :class:`DistributedArray` object,
+            :class:`cupy.ndarray` object or any other object that can be passed
+            to :func:`numpy.array`.
+        index_map (dict from int to array indices): Indices for the chunks
+            that devices with designated IDs own. One device can have multiple
+            chunks, which can be specified as a list of array indices.
+        mode (mode object, optional): Mode that determines how overlaps
+            of the chunks are interpreted. Defaults to
+            ``cupyx.distributed.array.REPLICA``.
+
+    .. seealso::
+            :attr:`DistributedArray.mode` for details about modes.
+
+    Example:
+        >>> array = cupy.arange(9).reshape(3, 3)
+        >>> A = distributed_array(
+        ...     array,
+        ...     {0: [(slice(2), slice(2)),  # array[:2, :2]
+        ...          slice(None, None, 2)], # array[::2]
+        ...      1:  (slice(1, None), 2)})  # array[1:, 2]
+    """
+    if isinstance(array, DistributedArray):
+        if array.mode != mode:
+            array = array.change_mode(mode)
+        if array.index_map != index_map:
+            array = array.reshard(index_map)
+        return DistributedArray(
+            array.shape, array.dtype, array._chunks_map, array._mode,
+            array._comms)
+
+    if isinstance(array, (numpy.ndarray, ndarray)):
+        if mode != _modes.REPLICA:
+            array = array.copy()
+    else:
+        array = numpy.array(array)
+
+    index_map = _index_arith._normalize_index_map(array.shape, index_map)
+    comms = None
+
+    # Define how to form a chunk from (dev, idx, src_array)
+    make_chunk: Callable[
+        [int, int, tuple[slice, ...], ndarray, Optional[list[Any]]],
+        _Chunk
+    ]
+
+    if isinstance(array, ndarray):
+        src_dev = array.device.id
+        devices = index_map.keys() | {array.device.id}
+        comms = _data_transfer._create_communicators(devices)
+        make_chunk = _make_chunk_async
+    else:
+        src_dev = -1
+        make_chunk = _make_chunk_sync
+
+    chunks_map: dict[int, list[_Chunk]] = {}
+    for dev, idxs in index_map.items():
+        chunks_map[dev] = []
+
+        for idx in idxs:
+            chunk_array = array[idx]
+            chunk = make_chunk(src_dev, dev, idx, chunk_array, comms)
+            chunks_map[dev].append(chunk)
+            if (mode is not _modes.REPLICA
+                    and not mode.idempotent):
+                array[idx] = mode.identity_of(array.dtype)
+
+    return DistributedArray(
+        array.shape, array.dtype, chunks_map, mode, comms)

vllm/lib/python3.10/site-packages/cupyx/distributed/array/_chunk.py

@@ -0,0 +1,228 @@
+import contextlib
+from itertools import chain
+from typing import Any, Iterator, Optional, Union
+
+import numpy
+
+from cupy._core.core import ndarray
+import cupy._creation.basic as _creation_basic
+import cupy._manipulation.dims as _manipulation_dims
+from cupy.cuda.device import Device
+from cupy.cuda.stream import Event
+from cupy.cuda.stream import Stream
+from cupy.cuda.stream import get_current_stream
+
+from cupyx.distributed.array import _modes
+from cupyx.distributed.array import _index_arith
+from cupyx.distributed.array import _data_transfer
+from cupyx.distributed.array._data_transfer import _Communicator
+
+
+class _ArrayPlaceholder:
+    # Mocks ndarray
+    # Eventually overwritten by PartialUpdates entirely, so
+    # any operation on _DataPlaceholder can be skipped
+    shape: tuple[int, ...]
+    device: Device
+
+    def __init__(self, shape: tuple[int, ...], device: Device) -> None:
+        self.shape = shape
+        self.device = device
+
+    def reshape(self, new_shape: tuple[int, ...]) -> '_ArrayPlaceholder':
+        return _ArrayPlaceholder(new_shape, self.device)
+
+    def to_ndarray(
+            self, mode: '_modes.Mode', dtype: numpy.dtype) -> ndarray:
+        with self.device:
+            if mode is _modes.REPLICA:
+                data = _creation_basic.empty(self.shape, dtype)
+            else:
+                value = mode.identity_of(dtype)
+                data = _creation_basic.full(self.shape, value, dtype)
+
+            # We avoid 0D array because we expect data[idx] to return a view
+            return _manipulation_dims.atleast_1d(data)
+
+
+class _Chunk:
+    array: Union[ndarray, _ArrayPlaceholder]
+    ready: Event
+    index: tuple[slice, ...]
+    updates: list[_data_transfer._PartialUpdate]
+    prevent_gc: Any = None     # TODO: Release it to avoid OOM
+
+    # Rule: whenever data is DataPlaceholder, ready is empty
+
+    def __init__(
+        self, data: Union[ndarray, _ArrayPlaceholder], ready: Event,
+        index: tuple[slice, ...],
+        updates: Optional[list[_data_transfer._PartialUpdate]] = None,
+        prevent_gc: Any = None
+    ) -> None:
+        self.array = data
+        self.ready = ready
+        self.index = index
+        self.updates = updates if updates is not None else []
+        self.prevent_gc = prevent_gc
+
+    @classmethod
+    def create_placeholder(
+        cls, shape: tuple[int, ...], device: Union[int, Device],
+        index: tuple[slice, ...],
+        updates: Optional[list[_data_transfer._PartialUpdate]] = None,
+    ) -> '_Chunk':
+        if isinstance(device, int):
+            device = Device(device)
+
+        data = _ArrayPlaceholder(shape, device)
+        with device:
+            ready = Event()
+        if updates is None:
+            updates = []
+
+        return _Chunk(data, ready, index, updates)
+
+    @contextlib.contextmanager
+    def on_ready(self) -> Iterator[Stream]:
+        with self.array.device:
+            stream = get_current_stream()
+            stream.wait_event(self.ready)
+            yield stream
+
+    def add_update(
+        self, update: _data_transfer._AsyncData, idx: tuple[slice, ...],
+    ) -> None:
+        self.updates.append((update, idx))
+
+    def copy(self) -> '_Chunk':
+        # TODO: Calling flush here would reduce the amount of future copying
+        if isinstance(self.array, _ArrayPlaceholder):
+            data = self.array
+            ready = self.ready
+        else:
+            with self.on_ready() as stream:
+                data = self.array.copy()
+                ready = stream.record()
+
+        return _Chunk(data, ready, self.index, list(self.updates),
+                      prevent_gc=self.prevent_gc)
+
+    def flush(self, mode: '_modes.Mode') -> None:
+        """Apply all updates in-place."""
+        if len(self.updates) == 0:
+            return
+
+        if isinstance(self.array, _ArrayPlaceholder):
+            dtype = self.updates[0][0].array.dtype
+            self.array = self.array.to_ndarray(mode, dtype)
+
+        with self.on_ready() as stream:
+            for update_data, idx in self.updates:
+                stream.wait_event(update_data.ready)
+                if mode is _modes.REPLICA:
+                    self.array[idx] = update_data.array
+                else:
+                    self.array[idx] = mode.func(
+                        self.array[idx], update_data.array)
+
+            stream.record(self.ready)
+            self.prevent_gc = (self.prevent_gc, self.updates)
+            self.updates = []
+
+    def apply_to(
+        self, target: '_Chunk', mode: '_modes.Mode',
+        shape: tuple[int, ...],
+        comms: dict[int, _data_transfer._Communicator],
+        streams: dict[int, Stream],
+    ) -> None:
+        # Overwrite target with mode.func(self, target) on their overlaps
+        # This is just appending part of self to target.updates in the mode
+        src_chunk = self
+        dst_chunk = target
+
+        assert len(src_chunk.updates) == 0
+        assert isinstance(src_chunk.array, ndarray)
+
+        src_dev = src_chunk.array.device.id
+        dst_dev = dst_chunk.array.device.id
+        src_idx = src_chunk.index
+        dst_idx = dst_chunk.index
+
+        intersection = _index_arith._index_intersection(
+            src_idx, dst_idx, shape)
+        if intersection is None:
+            return
+
+        src_new_idx = _index_arith._index_for_subindex(
+            src_idx, intersection, shape)
+        dst_new_idx = _index_arith._index_for_subindex(
+            dst_idx, intersection, shape)
+
+        data_to_transfer = _data_transfer._AsyncData(
+            src_chunk.array[src_new_idx], src_chunk.ready,
+            src_chunk.prevent_gc)
+
+        if mode is not _modes.REPLICA and not mode.idempotent:
+            data_to_transfer = data_to_transfer.copy()
+
+        update = _data_transfer._transfer(
+            comms[src_dev], streams[src_dev], data_to_transfer,
+            comms[dst_dev], streams[dst_dev], dst_dev)
+        dst_chunk.add_update(update, dst_new_idx)
+
+        if mode is not _modes.REPLICA and not mode.idempotent:
+            dtype = src_chunk.array.dtype
+            with data_to_transfer.on_ready() as stream:
+                # Now src data has been copied, so we can write on src_chunk
+                src_chunk.array[src_new_idx] = mode.identity_of(dtype)
+                stream.record(src_chunk.ready)
+
+    def set_identity_on_intersection(
+        self, idx: tuple[slice, ...], shape: tuple[int, ...], identity,
+    ) -> None:
+        assert isinstance(self.array, ndarray)
+
+        intersection = _index_arith._index_intersection(self.index, idx, shape)
+        if intersection is None:
+            return
+        self_new_idx = _index_arith._index_for_subindex(
+            self.index, intersection, shape)
+        with self.on_ready() as stream:
+            self.array[self_new_idx] = identity
+            stream.record(self.ready)
+
+    def set_identity_on_overwritten_entries(self, identity) -> None:
+        if isinstance(self.array, _ArrayPlaceholder):
+            return
+
+        with self.on_ready() as stream:
+            for _, idx in self.updates:
+                self.array[idx] = identity
+            stream.record(self.ready)
+
+
+def _all_reduce_intersections(
+    op_mode: '_modes._OpMode', shape: tuple[int, ...],
+    chunk_map: dict[int, list[_Chunk]],
+    comms: dict[int, _Communicator], streams: dict[int, Stream],
+) -> None:
+    chunks_list = list(chain.from_iterable(chunk_map.values()))
+
+    for i in range(len(chunks_list)):
+        src_chunk = chunks_list[i]
+        src_chunk.flush(op_mode)
+
+        for j in range(i + 1, len(chunks_list)):
+            dst_chunk = chunks_list[j]
+
+            src_chunk.apply_to(dst_chunk, op_mode, shape, comms, streams)
+
+    for j in range(len(chunks_list) - 1, -1, -1):
+        src_chunk = chunks_list[j]
+        src_chunk.flush(_modes.REPLICA)
+
+        for i in range(j):
+            dst_chunk = chunks_list[i]
+            src_chunk.apply_to(
+                dst_chunk, _modes.REPLICA, shape, comms, streams)

vllm/lib/python3.10/site-packages/cupyx/distributed/array/_data_transfer.py

@@ -0,0 +1,122 @@
+import contextlib
+import dataclasses
+from typing import Any, Iterable, Iterator
+
+from cupy._core.core import ndarray
+import cupy._creation.from_data as _creation_from_data
+import cupy._creation.basic as _creation_basic
+from cupy.cuda.device import Device
+from cupy.cuda.stream import Event
+from cupy.cuda.stream import Stream
+from cupy.cuda.stream import get_current_stream
+
+from cupy.cuda import nccl
+from cupyx.distributed._nccl_comm import _get_nccl_dtype_and_count
+
+if nccl.available:
+    from cupy.cuda.nccl import NcclCommunicator as _Communicator
+else:
+    class _MockCommunicator:
+        pass
+
+    _Communicator = _MockCommunicator
+
+
+@dataclasses.dataclass
+class _AsyncData:
+    array: ndarray
+    ready: Event
+    prevent_gc: Any = None      # TODO: Release it to avoid OOM
+
+    def copy(self) -> '_AsyncData':
+        with self.on_ready() as stream:
+            array = self.array.copy()
+            stream.record(self.ready)
+
+            return _AsyncData(array, stream.record(), self.prevent_gc)
+
+    @contextlib.contextmanager
+    def on_ready(self) -> Iterator[Stream]:
+        with self.array.device:
+            stream = get_current_stream()
+            stream.wait_event(self.ready)
+            yield stream
+
+
+# Overwrite in replica mode, apply in op mode
+_PartialUpdate = tuple[_AsyncData, tuple[slice, ...]]
+
+
+if nccl.available:
+    def _create_communicators(
+        devices: Iterable[int],
+    ) -> dict[int, _Communicator]:
+        comms_list = _Communicator.initAll(list(devices))
+        return {comm.device_id(): comm for comm in comms_list}
+
+    def _transfer(
+        src_comm: _Communicator, src_stream: Stream, src_data: _AsyncData,
+        dst_comm: _Communicator, dst_stream: Stream, dst_dev: int,
+    ) -> _AsyncData:
+        src_dev = src_data.array.device.id
+        if src_dev == dst_dev:
+            return _AsyncData(src_data.array, src_data.ready)
+
+        prev_src_stream = get_current_stream(src_dev)
+        prev_dst_stream = get_current_stream(dst_dev)
+        try:
+            with Device(src_dev):
+                src_stream.use()
+                src_stream.wait_event(src_data.ready)
+                src_array = _creation_from_data.ascontiguousarray(
+                    src_data.array)
+
+            with Device(dst_dev):
+                dst_stream.use()
+                dst_buf = _creation_basic.empty(
+                    src_array.shape, src_array.dtype)
+
+            dtype, count = _get_nccl_dtype_and_count(src_array)
+            nccl.groupStart()
+
+            with Device(src_dev):
+                src_comm.send(src_array.data.ptr, count, dtype,
+                              dst_comm.rank_id(), src_stream.ptr)
+
+            with Device(dst_dev):
+                dst_comm.recv(dst_buf.data.ptr, count, dtype,
+                              src_comm.rank_id(), dst_stream.ptr)
+
+                nccl.groupEnd()
+                return _AsyncData(dst_buf, dst_stream.record(),
+                                  prevent_gc=src_data)
+        finally:
+            with Device(src_dev):
+                prev_src_stream.use()
+            with Device(dst_dev):
+                prev_dst_stream.use()
+else:
+    def _create_communicators(
+        devices: Iterable[int],
+    ) -> dict[int, _Communicator]:
+        return {dev: _Communicator() for dev in devices}
+
+    def _transfer(
+        src_comm: _Communicator, src_stream: Stream, src_data: _AsyncData,
+        dst_comm: _Communicator, dst_stream: Stream, dst_dev: int,
+    ) -> _AsyncData:
+        src_dev = src_data.array.device.id
+        if src_dev == dst_dev:
+            return _AsyncData(src_data.array, src_data.ready)
+
+        with Device(dst_dev):
+            prev_stream = get_current_stream()
+            try:
+                dst_stream.use()
+                dst_stream.wait_event(src_data.ready)
+
+                dst_array = src_data.array.copy()
+                return _AsyncData(
+                    dst_array, dst_stream.record(), prevent_gc=src_data.array)
+            finally:
+                prev_stream.use()

vllm/lib/python3.10/site-packages/cupyx/distributed/array/_reduction.py

@@ -0,0 +1,90 @@
+import typing
+from typing import Any
+
+from numpy.typing import DTypeLike
+
+import cupy._manipulation.dims as _manipulation_dims
+from cupyx.distributed.array import _array
+from cupyx.distributed.array import _chunk
+from cupyx.distributed.array import _data_transfer
+from cupyx.distributed.array import _modes
+
+
+def _execute(
+    arr: '_array.DistributedArray', kernel, axis: int, dtype: DTypeLike,
+) -> Any:
+    overwrites = False
+    mode_overrides = {
+        'cupy_max': _modes.MAX,
+        'cupy_min': _modes.MIN,
+        'cupy_sum': _modes.SUM,
+        'cupy_prod': _modes.PROD,
+    }
+    if kernel.name not in mode_overrides:
+
+        raise RuntimeError(f'Unsupported kernel: {kernel.name}')
+    mode = mode_overrides[kernel.name]
+    if mode in (_modes.MAX, _modes.MIN):
+        if arr._mode is not mode:
+            arr = arr._to_op_mode(_modes.REPLICA)
+            overwrites = True
+    else:
+        arr = arr._to_op_mode(mode)
+
+    chunks_map = arr._chunks_map
+
+    if overwrites:
+        mode = typing.cast(_modes._OpMode, mode)
+        identity = mode.identity_of(arr.dtype)
+        for chunks in chunks_map.values():
+            for i in range(len(chunks)):
+                if len(chunks[i].updates) == 0:
+                    continue
+                chunks[i] = chunks[i].copy()
+                chunks[i].set_identity_on_overwritten_entries(identity)
+
+    shape = arr.shape[:axis] + arr.shape[axis+1:]
+    out_dtype = None
+    out_chunks_map: dict[int, list[_chunk._Chunk]] = {}
+
+    for dev, chunks in chunks_map.items():
+        out_chunks_map[dev] = []
+        for chunk in chunks:
+            with chunk.on_ready() as stream:
+                out_index = chunk.index[:axis] + chunk.index[axis+1:]
+
+                if isinstance(chunk.array, _chunk._ArrayPlaceholder):
+                    old_shape = chunk.array.shape
+                    out_shape = old_shape[:axis] + old_shape[axis+1:]
+                    out_chunk = _chunk._Chunk.create_placeholder(
+                        out_shape, chunk.array.device, out_index)
+                else:
+                    # We avoid 0D array because
+                    # we expect data[idx] to return a view
+                    out_array = _manipulation_dims.atleast_1d(
+                        kernel(chunk.array, axis=axis, dtype=dtype))
+
+                    out_dtype = out_array.dtype
+                    out_chunk = _chunk._Chunk(
+                        out_array, stream.record(), out_index,
+                        prevent_gc=chunk.prevent_gc)
+
+                out_chunks_map[dev].append(out_chunk)
+
+                if len(chunk.updates) == 0:
+                    continue
+
+                for update, update_index in chunk.updates:
+                    stream.wait_event(update.ready)
+                    out_update_array = _manipulation_dims.atleast_1d(
+                        kernel(update.array, axis=axis, dtype=dtype))
+                    out_dtype = out_update_array.dtype
+
+                    out_update = _data_transfer._AsyncData(
+                        out_update_array, stream.record(),
+                        prevent_gc=update.prevent_gc)
+                    out_index = update_index[:axis] + update_index[axis+1:]
+                    out_chunk.add_update(out_update, out_index)
+
+    return _array.DistributedArray(
+        shape, out_dtype, out_chunks_map, mode, arr._comms)

vllm/lib/python3.10/site-packages/cupyx/jit/__init__.py

@@ -0,0 +1,36 @@
+from cupyx.jit._interface import rawkernel  # NOQA
+
+from cupyx.jit._interface import threadIdx  # NOQA
+from cupyx.jit._interface import blockDim  # NOQA
+from cupyx.jit._interface import blockIdx  # NOQA
+from cupyx.jit._interface import gridDim  # NOQA
+from cupyx.jit._interface import warpsize  # NOQA
+
+from cupyx.jit._builtin_funcs import range_ as range  # NOQA
+from cupyx.jit._builtin_funcs import syncthreads  # NOQA
+from cupyx.jit._builtin_funcs import syncwarp  # NOQA
+from cupyx.jit._builtin_funcs import shared_memory  # NOQA
+from cupyx.jit._builtin_funcs import atomic_add  # NOQA
+from cupyx.jit._builtin_funcs import atomic_sub  # NOQA
+from cupyx.jit._builtin_funcs import atomic_exch  # NOQA
+from cupyx.jit._builtin_funcs import atomic_min  # NOQA
+from cupyx.jit._builtin_funcs import atomic_max  # NOQA
+from cupyx.jit._builtin_funcs import atomic_inc  # NOQA
+from cupyx.jit._builtin_funcs import atomic_dec  # NOQA
+from cupyx.jit._builtin_funcs import atomic_cas  # NOQA
+from cupyx.jit._builtin_funcs import atomic_and  # NOQA
+from cupyx.jit._builtin_funcs import atomic_or  # NOQA
+from cupyx.jit._builtin_funcs import atomic_xor  # NOQA
+from cupyx.jit._builtin_funcs import grid  # NOQA
+from cupyx.jit._builtin_funcs import gridsize  # NOQA
+from cupyx.jit._builtin_funcs import laneid  # NOQA
+from cupyx.jit._builtin_funcs import shfl_sync  # NOQA
+from cupyx.jit._builtin_funcs import shfl_up_sync  # NOQA
+from cupyx.jit._builtin_funcs import shfl_down_sync  # NOQA
+from cupyx.jit._builtin_funcs import shfl_xor_sync  # NOQA
+
+from cupyx.jit import cg  # NOQA
+from cupyx.jit import cub  # NOQA
+from cupyx.jit import thrust  # NOQA
+
+_n_functions_upperlimit = 100