Add files using upload-large-folder tool

.gitattributes

@@ -1703,3 +1703,4 @@ vllm/lib/python3.10/site-packages/tiktoken/_tiktoken.cpython-310-x86_64-linux-gn
 parrot/lib/python3.10/site-packages/scipy/cluster/_hierarchy.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/scipy/stats/_ansari_swilk_statistics.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/scipy/special/_test_internal.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+vllm/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__pycache__/axes3d.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/jit/passes/quantization/fusion_passes.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <torch/csrc/jit/ir/ir.h>
+
+namespace torch {
+namespace jit {
+TORCH_API void FuseQuantizedAddRelu(std::shared_ptr<Graph>& graph);
+} // namespace jit
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/jit/passes/quantization/helper.h

@@ -0,0 +1,216 @@
+#pragma once
+#include <torch/csrc/jit/api/module.h>
+#include <torch/csrc/jit/ir/ir.h>
+#include <torch/csrc/jit/ir/subgraph_matcher.h>
+#include <torch/csrc/jit/passes/graph_rewrite_helper.h>
+#include <torch/csrc/jit/passes/quantization/quantization_type.h>
+
+#include <functional>
+#include <regex>
+
+namespace torch {
+namespace jit {
+
+using graph_rewrite_helper::getFuncName;
+
+// Vector of a module and the name of its method
+using ModuleMethodVector = std::vector<std::pair<Module, std::string>>;
+// Map of quantization parameter name and value
+// for example _scale, _zero_point,
+// _scalar_type and _axis(for per channel quantization)
+using QParamVector = std::vector<std::pair<std::string, IValue>>;
+
+// =========== helper functions for Value =========
+// Check if a value is weight, since we need to use weight observer
+// for weight
+TORCH_API bool isWeight(Value* v);
+
+// Check if a value is bias for conv and linear, which we do not
+// quantize
+TORCH_API bool isBiasOfConvOrLinear(Value* v);
+
+TORCH_API bool isEmbeddingBagNonInput(Value* v);
+
+// Get the use as scalar input of clamp ops for the input value
+c10::optional<Use> getClampScalarInputUse(Value* v);
+
+// For a given value `v`, get the list of values that we need to check
+// if they are observed/quantized or not, if so, we can say the
+// `v` is also observed/quantized, since we can derive
+// the quantization parameters for `v` given the list of values
+TORCH_API std::vector<Value*> getPassThroughInputs(Value* v);
+
+// Clones the method by the name of orig_method_name into new_method_name method
+TORCH_API void cloneMethod(
+    Module& module,
+    const std::string& orig_method_name,
+    const std::string& new_method_name);
+
+// Check if a value in the graph is a Scalar value
+TORCH_API bool isScalar(Value* v);
+
+// Check if value is the input of the graph
+TORCH_API bool hitGraphInput(Value* value);
+
+// Converts a mangled name, such as
+//   __torch__.torch.ao.nn.quantized.modules.conv.___torch_mangle_7.Conv2d
+// into an unmangled name, such as
+//   __torch__.torch.ao.nn.quantized.modules.conv.Conv2d
+TORCH_API std::string removeTorchMangle(const std::string& orig_name);
+
+// Return the module name that corresponds to the value.
+TORCH_API c10::optional<std::string> getModuleName(Value* value);
+
+// =========== helper functions for Node =========
+TORCH_API bool isSingleInputGeneralShapeAtenFunction(Node* n);
+
+TORCH_API bool isSingleInputGeneralValueAtenFunction(Node* n);
+
+TORCH_API bool isSingleInputGeneralCallFunction(Node* n);
+
+TORCH_API bool isSingleInputGeneralAtenFunction(Node* n);
+
+TORCH_API bool isClamp(Node* n);
+
+// Check if the node will produce the same result regardless of whether
+// the input tensor is quantized or not, example: aten::size
+TORCH_API bool isTensorInfoNode(Node* n);
+
+// Check if this the propagate op that has single input, e.g. aten::cat
+TORCH_API bool isPropagateQuantSingleInputOp(Node* n);
+
+// Check if this is the propagate op that has two inputs, e.g. aten::add
+TORCH_API bool isPropagateQuantBinaryOp(Node* n);
+
+// Check if this is the node that we'll quantize or not quantize depending on
+// whether the input of the node is quantized, example: aten::cat
+TORCH_API bool isPropagateQuantOp(Node* n);
+
+// Check if the node is a binary op like aten::add and aten::mul and
+// if the input 1 is a scalar, these ops will be quantized to
+// quantized::{op}_scalar
+TORCH_API bool isBinaryOpWithScalarInput(Node* n);
+
+TORCH_API c10::optional<std::tuple<c10::QScheme, QParamVector>> getFixedQParams(
+    Node* n);
+
+// We don't want to analyze the graph for some `builtin` CallFunctions
+// like `linear` because we want to preserve the op boundary
+TORCH_API bool userDefinedCallFunction(Node* n);
+
+// Check if the node has scalar input
+TORCH_API bool hasScalarInput(Node* n);
+
+// Check if a node is quantizable
+TORCH_API bool nodeQuantizable(
+    Node* n,
+    QuantType quant_type = QuantType::STATIC);
+
+// Nodes which only require quantization of weight value, eg. embedding_bag
+bool isWeightOnlyStaticQuantOp(Node* n);
+
+// Check if a use of the value is quantizable, this depends on
+// both the use node and the offset
+TORCH_API bool useQuantizable(const Use& use, QuantType quant_type);
+
+// Given a CallFunction node, extract the graph of the called function
+TORCH_API std::shared_ptr<Graph> getCallFunctionGraph(Node* n);
+
+// Check if `use` is a CallFunction of name `func_name` and if value
+// `v` is the nth argument (if provided) of the function
+bool matchCallFuncToUse(
+    const Use& use,
+    const std::string& func_name,
+    c10::optional<int> nth_arg);
+
+// Check if `use` is a AtenFunction of name `func_name` and if value
+// `v` is the nth argument (if provided) of the function
+bool matchAtenFuncToUse(
+    const Use& use,
+    const std::string& func_name,
+    c10::optional<int> nth_arg);
+
+// =========== helper functions for Block =========
+// checks if a block will always raise an Exception
+TORCH_API bool alwaysRaisesException(Block* block);
+
+// =========== helper functions for Module  ==========
+// TODO: remove
+TORCH_API std::vector<std::string> getModuleAccessPath(
+    Value* instance,
+    Value* self);
+// TODO: remove
+TORCH_API Module
+findChildModule(const Module& module, const std::vector<std::string>& path);
+
+// Given an CallMethod node, get the module instance corresponding
+// to the instance Value
+// TODO: refactor all current uses of this function to the Opt one
+TORCH_API Module getInvokedModule(Module& module, Node* n, Value* self);
+
+// Given an CallMethod node, get the module instance corresponding
+// to the instance Value if the instance is a module, otherwise return
+// c10::nullopt
+c10::optional<Module> getInvokedModuleOpt(
+    const Module& module,
+    Node* n,
+    Value* self);
+
+// ==================== filter functions for matches ==============
+// filter to check Value `vname` is a constant of int value `value`
+bool is_int_constant(
+    const Match& match,
+    const std::unordered_map<std::string, Value*>& vmap,
+    const std::string& vname,
+    int value);
+
+// filter to check if the %alpha argument of aten::add is constant 1
+bool aten_add_alpha_is_one(
+    const Match& match,
+    const std::unordered_map<std::string, Value*>& vmap);
+
+// filter to check if the functional in CallFunction is relu
+bool is_functional_relu(
+    const Match& match,
+    const std::unordered_map<std::string, Value*>& vmap);
+
+// filter to check if the module is torch.nn.ReLU
+bool is_relu_module(
+    const Match& match,
+    const std::unordered_map<std::string, Value*>& vmap);
+
+bool is_linear_module(
+    const Match& match,
+    const std::unordered_map<std::string, Value*>& vmap);
+
+// TODO: add a macro to declare the filters
+bool is_conv1d_module(
+    const Match& match,
+    const std::unordered_map<std::string, Value*>& vmap);
+
+bool is_conv2d_module(
+    const Match& match,
+    const std::unordered_map<std::string, Value*>& vmap);
+
+bool is_conv3d_module(
+    const Match& match,
+    const std::unordered_map<std::string, Value*>& vmap);
+
+bool is_conv_transpose1d_module(
+    const Match& match,
+    const std::unordered_map<std::string, Value*>& vmap);
+
+bool is_conv_transpose2d_module(
+    const Match& match,
+    const std::unordered_map<std::string, Value*>& vmap);
+
+bool is_batchnorm2d_module(
+    const Match& match,
+    const std::unordered_map<std::string, Value*>& vmap);
+
+bool is_batchnorm3d_module(
+    const Match& match,
+    const std::unordered_map<std::string, Value*>& vmap);
+
+} // namespace jit
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/jit/passes/quantization/insert_observers.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <torch/csrc/jit/api/module.h>
+#include <torch/csrc/jit/passes/quantization/quantization_type.h>
+
+namespace std {
+
+template <>
+struct hash<torch::jit::Module> {
+  inline size_t operator()(const torch::jit::Module& arg) const {
+    return std::hash<c10::intrusive_ptr<c10::ivalue::Object>>()(arg._ivalue());
+  }
+};
+
+} // namespace std
+
+namespace torch {
+namespace jit {
+
+using QConfig = std::tuple<Module, Module>;
+using QConfigDict = std::unordered_map<std::string, c10::optional<QConfig>>;
+
+/** \brief Insert observer module and observer function call for
+ *  the Tensors that needs to be observed.
+ *
+ * For each Tensor that needs to be observed in the method, insert observer
+ * module to the input module and add forward calls of observer to the specified
+ * method.
+ *
+ * \param module the input module
+ * \param method_name the method we want to insert observers for
+ * \param qconfig_dict the qconfig dictionary that specifies how
+ * each module is going to be quantized
+ * \param inplace whether we want to do inplace modification to the input module
+ * or clone the module
+ * \param is_dynamic whether the dynamic quantization script is being used.
+ */
+TORCH_API Module InsertObservers(
+    Module& module,
+    const std::string& method_name,
+    const QConfigDict& qconfig_dict,
+    bool inplace,
+    QuantType quant_type = QuantType::STATIC);
+
+/** \brief Insert observer module and observer method for
+ *  the Tensors that needs to be observed.
+ *
+ * For each Tensor that needs to be observed in the method, insert observer
+ * module to the input module and observe_<method-name> methods to the module.
+ * This method is clone of mehtod_name with forward calls of observer added.
+ *
+ * \param module the input module
+ * \param method_name the method we want to insert observers for
+ * \param qconfig_dict the qconfig dictionary that specifies how
+ * each module is going to be quantized
+ * \param inplace whether we want to do inplace modification to the input module
+ * or clone the module
+ * \param is_dynamic whether the dynamic quantization script is being used.
+ */
+TORCH_API Module InsertObserversForOnDevicePTQ(
+    Module& module,
+    const std::string& method_name,
+    const QConfigDict& qconfig_dict,
+    bool inplace,
+    QuantType quant_type = QuantType::STATIC);
+
+} // namespace jit
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/jit/passes/utils/op_registry.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <torch/csrc/Export.h>
+#include <torch/csrc/jit/ir/ir.h>
+#include <memory>
+
+namespace torch {
+namespace jit {
+// Moved from shape_analysis.cpp
+
+// Requirements:
+//   dims           : preserved from the first argument
+//   scalar type    : preserved from the first argument (doesn't have to
+//                    match other arguments)
+//   device         : always matching and preserved
+//   tensor inputs  : *
+//   tensor outputs : 1
+// NB: those ops (with slight adjustments) are good candidates for restarts.
+//     Knowing the type and device of weights or biases is usually enough to
+//     infer the output type.
+std::shared_ptr<OperatorSet> nn_ops_first_input_preserving();
+
+// Requirements:
+//   dims           : Changed from first argument
+//   scalar type    : preserved from the first argument
+//   device         : always matching and preserved
+//   tensor inputs  : 1
+//   tensor outputs : 1
+std::shared_ptr<OperatorSet> ops_one_tensor_in_shape_transform();
+} // namespace jit
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/jit/passes/utils/optimization_utils.h

@@ -0,0 +1,14 @@
+
+#pragma once
+
+#include <torch/csrc/jit/ir/ir.h>
+
+namespace torch {
+namespace jit {
+
+// Checks if the parameters, not including the
+// first param are all constants.
+bool nonConstantParameters(Node* n);
+
+} // namespace jit
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/jit/passes/utils/subgraph_utils.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <torch/csrc/Export.h>
+#include <torch/csrc/jit/ir/alias_analysis.h>
+#include <torch/csrc/jit/ir/ir.h>
+
+namespace torch {
+namespace jit {
+
+// Utilities for dealing with nodes that contain subgraphs.
+//
+// They handle the complexity of editing inputs/outputs as you merge nodes in
+// and out of subgraphs.
+namespace SubgraphUtils {
+
+// Create a new subgraph node that contains only `n`. The new subgraph will have
+// `subgraphKind` as its type.
+//
+// `n` is destroyed.
+//
+// Returns the new subgraph node.
+TORCH_API Node* createSingletonSubgraph(Node* n, Symbol subgraphKind);
+
+// Creates a new subgraph that only contains `n`, amd updates the new outputs
+// of the subgraph to have the aliasing properties of the original `n` outputs
+TORCH_API Node* createSingletonSubgraphAndUpdateAliasing(
+    Node* to_merge,
+    Symbol subgraphKind,
+    AliasDb& db);
+
+// Merge a node into a subgraph node. If `toMerge` is also a subgraph, the
+// subgraphs are merged.
+// If `destroyNode` is true `toMerge` is destroyed.
+// An optional argument 'vmap' could be used to retrieve value mappings.
+// Values will be mapped to their new subgraph values
+TORCH_API void mergeNodeIntoSubgraph(
+    Node* toMerge,
+    Node* subgraphNode,
+    bool destroyNode = true);
+
+// Merges a node into a subgraph node, and updates the new outputs of the
+// subgraph to have the aliasing properties of the corresponding `to_merge`
+// outputs
+TORCH_API void mergeNodeIntoSubgraphAndUpdateAliasing(
+    Node* to_merge,
+    Node* subgraphNode,
+    AliasDb& db);
+
+TORCH_API std::vector<Node*> unmergeAliasedOutputs(
+    Node* subgraphNode,
+    AliasDb& db);
+
+// Move nodes from a subgraph node to the outer graph.
+// `subgraphNode` is destroyed.
+TORCH_API void unmergeSubgraph(Node* subgraphNode);
+
+// Move `node_to_unmerge` and its descendants after `subgraphNode`
+// promotes any dependencies of `node_to_unmerge` to subgraphNode outputs
+TORCH_API void unmergeNode(Node* node_to_unmerge, Node* subgraphNode);
+
+TORCH_API bool unmergeOutputsAlisingInputs(Node* subgraphNode);
+
+TORCH_API bool unmergeAliasedOutputs(Node* subgraphNode);
+
+// Convenience function
+std::shared_ptr<Graph> getSubgraph(Node* n);
+
+TORCH_API std::string generateNameForGraph(
+    const std::shared_ptr<Graph>& graph,
+    size_t maxlen = 40,
+    const std::string& prefix = "fused");
+
+} // namespace SubgraphUtils
+} // namespace jit
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/jit/tensorexpr/ir_printer.h

@@ -0,0 +1,130 @@
+#pragma once
+
+#include <ostream>
+
+#include <torch/csrc/jit/tensorexpr/fwd_decls.h>
+#include <torch/csrc/jit/tensorexpr/ir.h>
+#include <torch/csrc/jit/tensorexpr/ir_visitor.h>
+#include <torch/csrc/jit/tensorexpr/unique_name_manager.h>
+
+namespace torch {
+namespace jit {
+namespace tensorexpr {
+
+class Tensor;
+
+class TORCH_API IRPrinter : public IRVisitor {
+ public:
+  explicit IRPrinter(std::ostream& os) : printer_os_(this, os) {}
+
+  void print(ExprHandle);
+  void print(Expr&);
+  void print(Stmt&);
+  void visit(AddPtr v) override;
+  void visit(SubPtr v) override;
+  void visit(MulPtr v) override;
+  void visit(DivPtr v) override;
+  void visit(ModPtr v) override;
+  void visit(MaxPtr v) override;
+  void visit(MinPtr v) override;
+  void visit(AndPtr v) override;
+  void visit(OrPtr v) override;
+  void visit(XorPtr v) override;
+  void visit(LshiftPtr v) override;
+  void visit(RshiftPtr v) override;
+  void visit(CompareSelectPtr v) override;
+#define IMM_PRINT_VISIT(Type, Name) void visit(Name##ImmPtr v) override;
+  AT_FORALL_SCALAR_TYPES_AND3(Bool, Half, BFloat16, IMM_PRINT_VISIT);
+#undef IMM_PRINT_VISIT
+  void visit(CastPtr v) override;
+  void visit(BitCastPtr v) override;
+  void visit(VarPtr v) override;
+  void visit(BufPtr v) override;
+  void visit(RampPtr v) override;
+  void visit(LoadPtr v) override;
+  void visit(BroadcastPtr v) override;
+  void visit(IfThenElsePtr v) override;
+  void visit(IntrinsicsPtr v) override;
+  void visit(TermPtr v) override;
+  void visit(PolynomialPtr v) override;
+  void visit(RoundOffPtr v) override;
+  void visit(MaxTermPtr v) override;
+  void visit(MinTermPtr v) override;
+  void visit(ReduceOpPtr v) override;
+
+  void visit(AtomicAddPtr v) override;
+  void visit(SyncThreadsPtr v) override;
+  void visit(ExternalCallPtr v) override;
+  void visit(ExternalCallWithAllocPtr v) override;
+  void visit(StorePtr v) override;
+  void visit(ForPtr v) override;
+  void visit(CondPtr v) override;
+  void visit(BlockPtr v) override;
+  void visit(AllocatePtr v) override;
+  void visit(FreePtr v) override;
+  void visit(FreeExtPtr v) override;
+  void visit(PlacementAllocatePtr v) override;
+  void visit(LetPtr v) override;
+
+  // A child class may have a difference rule for generating dtype
+  // string, e.g. CUDA needs int64_t to be generated as long long.
+  virtual std::string dtypeToCppString(const Dtype& dtype);
+
+  std::ostream& os() {
+    return printer_os_;
+  }
+
+  class PrinterStream : public std::ostream {
+   public:
+    PrinterStream(IRPrinter* printer, std::ostream& os)
+        : std::ostream(os.rdbuf()), printer_(printer) {}
+
+    IRPrinter* printer() {
+      return printer_;
+    }
+
+   private:
+    IRPrinter* printer_ = nullptr;
+  };
+
+ protected:
+  std::string to_string(CompareSelectOperation op);
+
+  UniqueNameManager* name_manager() {
+    return &name_manager_;
+  }
+  void emitIndent();
+
+  // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
+  int indent_ = 0;
+
+ private:
+  PrinterStream printer_os_;
+  UniqueNameManager name_manager_;
+};
+
+TORCH_API std::ostream& operator<<(std::ostream& stream, const Expr&);
+TORCH_API std::ostream& operator<<(std::ostream& stream, const ExprHandle&);
+TORCH_API std::ostream& operator<<(std::ostream& stream, const Stmt&);
+TORCH_API std::ostream& operator<<(std::ostream& stream, const Tensor&);
+
+TORCH_API void print(ExprPtr expr);
+TORCH_API void print(StmtPtr stmt);
+TORCH_API void print(const Tensor& t);
+
+} // namespace tensorexpr
+} // namespace jit
+} // namespace torch
+
+namespace std {
+
+using torch::jit::tensorexpr::Expr;
+using torch::jit::tensorexpr::ExprPtr;
+using torch::jit::tensorexpr::Stmt;
+using torch::jit::tensorexpr::StmtPtr;
+using torch::jit::tensorexpr::Tensor;
+
+TORCH_API std::string to_string(ExprPtr expr);
+TORCH_API std::string to_string(StmtPtr stmt);
+TORCH_API std::string to_string(const Tensor& t);
+} // namespace std

vllm/lib/python3.10/site-packages/cupy/_manipulation/add_remove.py

@@ -0,0 +1,361 @@
+import numpy
+
+import cupy
+import math
+from cupy import _core
+
+
+def delete(arr, indices, axis=None):
+    """
+    Delete values from an array along the specified axis.
+
+    Args:
+        arr (cupy.ndarray):
+            Values are deleted from a copy of this array.
+        indices (slice, int or array of ints):
+            These indices correspond to values that will be deleted from the
+            copy of `arr`.
+            Boolean indices are treated as a mask of elements to remove.
+        axis (int or None):
+            The axis along which `indices` correspond to values that will be
+            deleted. If `axis` is not given, `arr` will be flattened.
+
+    Returns:
+        cupy.ndarray:
+            A copy of `arr` with values specified by `indices` deleted along
+            `axis`.
+
+    .. warning:: This function may synchronize the device.
+
+    .. seealso:: :func:`numpy.delete`.
+    """
+
+    if axis is None:
+
+        arr = arr.ravel()
+
+        if isinstance(indices, cupy.ndarray) and indices.dtype == cupy.bool_:
+            return arr[~indices]
+
+        mask = cupy.ones(arr.size, dtype=bool)
+        mask[indices] = False
+        return arr[mask]
+
+    else:
+
+        if isinstance(indices, cupy.ndarray) and indices.dtype == cupy.bool_:
+            return cupy.compress(~indices, arr, axis=axis)
+
+        mask = cupy.ones(arr.shape[axis], dtype=bool)
+        mask[indices] = False
+        return cupy.compress(mask, arr, axis=axis)
+
+
+# TODO(okuta): Implement insert
+
+
+def append(arr, values, axis=None):
+    """
+    Append values to the end of an array.
+
+    Args:
+        arr (array_like):
+            Values are appended to a copy of this array.
+        values (array_like):
+            These values are appended to a copy of ``arr``.  It must be of the
+            correct shape (the same shape as ``arr``, excluding ``axis``).  If
+            ``axis`` is not specified, ``values`` can be any shape and will be
+            flattened before use.
+        axis (int or None):
+            The axis along which ``values`` are appended.  If ``axis`` is not
+            given, both ``arr`` and ``values`` are flattened before use.
+
+    Returns:
+        cupy.ndarray:
+            A copy of ``arr`` with ``values`` appended to ``axis``.  Note that
+            ``append`` does not occur in-place: a new array is allocated and
+            filled.  If ``axis`` is None, ``out`` is a flattened array.
+
+    .. seealso:: :func:`numpy.append`
+    """
+    # TODO(asi1024): Implement fast path for scalar inputs.
+    arr = cupy.asarray(arr)
+    values = cupy.asarray(values)
+    if axis is None:
+        return _core.concatenate_method(
+            (arr.ravel(), values.ravel()), 0).ravel()
+    return _core.concatenate_method((arr, values), axis)
+
+
+_resize_kernel = _core.ElementwiseKernel(
+    'raw T x, int64 size', 'T y',
+    'y = x[i % size]',
+    'cupy_resize',
+)
+
+
+def resize(a, new_shape):
+    """Return a new array with the specified shape.
+
+    If the new array is larger than the original array, then the new
+    array is filled with repeated copies of ``a``.  Note that this behavior
+    is different from a.resize(new_shape) which fills with zeros instead
+    of repeated copies of ``a``.
+
+    Args:
+        a (array_like): Array to be resized.
+        new_shape (int or tuple of int): Shape of resized array.
+
+    Returns:
+        cupy.ndarray:
+            The new array is formed from the data in the old array, repeated
+            if necessary to fill out the required number of elements.  The
+            data are repeated in the order that they are stored in memory.
+
+    .. seealso:: :func:`numpy.resize`
+    """
+    if numpy.isscalar(a):
+        return cupy.full(new_shape, a)
+    a = cupy.asarray(a)
+    if a.size == 0:
+        return cupy.zeros(new_shape, dtype=a.dtype)
+    out = cupy.empty(new_shape, a.dtype)
+    _resize_kernel(a, a.size, out)
+    return out
+
+
+_first_nonzero_krnl = _core.ReductionKernel(
+    'T data, int64 len',
+    'int64 y',
+    'data == T(0) ? len : _j',
+    'min(a, b)',
+    'y = a',
+    'len',
+    'first_nonzero'
+)
+
+
+def trim_zeros(filt, trim='fb'):
+    """Trim the leading and/or trailing zeros from a 1-D array or sequence.
+
+    Returns the trimmed array
+
+    Args:
+        filt(cupy.ndarray): Input array
+        trim(str, optional):
+            'fb' default option trims the array from both sides.
+            'f' option trim zeros from front.
+            'b' option trim zeros from back.
+
+    Returns:
+        cupy.ndarray: trimmed input
+
+    .. seealso:: :func:`numpy.trim_zeros`
+
+    """
+    if filt.ndim > 1:
+        raise ValueError('Multi-dimensional trim is not supported')
+    if not filt.ndim:
+        raise TypeError('0-d array cannot be trimmed')
+    start = 0
+    end = filt.size
+    trim = trim.upper()
+    if 'F' in trim:
+        start = _first_nonzero_krnl(filt, filt.size).item()
+    if 'B' in trim:
+        end = filt.size - _first_nonzero_krnl(filt[::-1], filt.size).item()
+    return filt[start:end]
+
+
+@_core.fusion.fuse()
+def _unique_update_mask_equal_nan(mask, x0):
+    mask1 = cupy.logical_not(cupy.isnan(x0))
+    mask[:] = cupy.logical_and(mask, mask1)
+
+
+def unique(ar, return_index=False, return_inverse=False,
+           return_counts=False, axis=None, *, equal_nan=True):
+    """Find the unique elements of an array.
+
+    Returns the sorted unique elements of an array. There are three optional
+    outputs in addition to the unique elements:
+
+    * the indices of the input array that give the unique values
+    * the indices of the unique array that reconstruct the input array
+    * the number of times each unique value comes up in the input array
+
+    Args:
+        ar(array_like): Input array. This will be flattened if it is not
+            already 1-D.
+        return_index(bool, optional): If True, also return the indices of `ar`
+            (along the specified axis, if provided, or in the flattened array)
+            that result in the unique array.
+        return_inverse(bool, optional): If True, also return the indices of the
+            unique array (for the specified axis, if provided) that can be used
+            to reconstruct `ar`.
+        return_counts(bool, optional): If True, also return the number of times
+            each unique item appears in `ar`.
+        axis(int or None, optional): The axis to operate on. If None, ar will
+            be flattened. If an integer, the subarrays indexed by the given
+            axis will be flattened and treated as the elements of a 1-D array
+            with the dimension of the given axis, see the notes for more
+            details. The default is None.
+        equal_nan(bool, optional): If True, collapse multiple NaN values in the
+            return array into one.
+
+    Returns:
+        cupy.ndarray or tuple:
+            If there are no optional outputs, it returns the
+            :class:`cupy.ndarray` of the sorted unique values. Otherwise, it
+            returns the tuple which contains the sorted unique values and
+            following.
+
+            * The indices of the first occurrences of the unique values in the
+              original array. Only provided if `return_index` is True.
+            * The indices to reconstruct the original array from the
+              unique array. Only provided if `return_inverse` is True.
+            * The number of times each of the unique values comes up in the
+              original array. Only provided if `return_counts` is True.
+
+    Notes:
+       When an axis is specified the subarrays indexed by the axis are sorted.
+       This is done by making the specified axis the first dimension of the
+       array (move the axis to the first dimension to keep the order of the
+       other axes) and then flattening the subarrays in C order.
+
+    .. warning::
+
+        This function may synchronize the device.
+
+    .. seealso:: :func:`numpy.unique`
+    """
+    if axis is None:
+        ret = _unique_1d(ar, return_index=return_index,
+                         return_inverse=return_inverse,
+                         return_counts=return_counts,
+                         equal_nan=equal_nan)
+        return ret
+
+    ar = cupy.moveaxis(ar, axis, 0)
+
+    # The array is reshaped into a contiguous 2D array
+    orig_shape = ar.shape
+    idx = cupy.arange(0, orig_shape[0], dtype=cupy.intp)
+    ar = ar.reshape(orig_shape[0], math.prod(orig_shape[1:]))
+    ar = cupy.ascontiguousarray(ar)
+    is_unsigned = cupy.issubdtype(ar.dtype, cupy.unsignedinteger)
+    is_complex = cupy.iscomplexobj(ar)
+
+    ar_cmp = ar
+    if is_unsigned:
+        ar_cmp = ar.astype(cupy.intp)
+
+    def compare_axis_elems(idx1, idx2):
+        left, right = ar_cmp[idx1], ar_cmp[idx2]
+        comp = cupy.trim_zeros(left - right, 'f')
+        if comp.shape[0] > 0:
+            diff = comp[0]
+            if is_complex and cupy.isnan(diff):
+                return True
+            return diff < 0
+        return False
+
+    # The array is sorted lexicographically using the first item of each
+    # element on the axis
+    sorted_indices = cupy.empty(orig_shape[0], dtype=cupy.intp)
+    queue = [(idx.tolist(), 0)]
+    while queue != []:
+        current, off = queue.pop(0)
+        if current == []:
+            continue
+
+        mid_elem = current[0]
+        left = []
+        right = []
+        for i in range(1, len(current)):
+            if compare_axis_elems(current[i], mid_elem):
+                left.append(current[i])
+            else:
+                right.append(current[i])
+
+        elem_pos = off + len(left)
+        queue.append((left, off))
+        queue.append((right, elem_pos + 1))
+
+        sorted_indices[elem_pos] = mid_elem
+
+    ar = ar[sorted_indices]
+
+    if ar.size > 0:
+        mask = cupy.empty(ar.shape, dtype=cupy.bool_)
+        mask[:1] = True
+        mask[1:] = ar[1:] != ar[:-1]
+
+        mask = cupy.any(mask, axis=1)
+    else:
+        # If empty, then the mask should grab the first empty array as the
+        # unique one
+        mask = cupy.ones((ar.shape[0]), dtype=cupy.bool_)
+        mask[1:] = False
+
+    # Index the input array with the unique elements and reshape it into the
+    # original size and dimension order
+    ar = ar[mask]
+    ar = ar.reshape(mask.sum().item(), *orig_shape[1:])
+    ar = cupy.moveaxis(ar, 0, axis)
+
+    ret = ar,
+    if return_index:
+        ret += sorted_indices[mask],
+    if return_inverse:
+        imask = cupy.cumsum(mask) - 1
+        inv_idx = cupy.empty(mask.shape, dtype=cupy.intp)
+        inv_idx[sorted_indices] = imask
+        ret += inv_idx,
+    if return_counts:
+        nonzero = cupy.nonzero(mask)[0]  # may synchronize
+        idx = cupy.empty((nonzero.size + 1,), nonzero.dtype)
+        idx[:-1] = nonzero
+        idx[-1] = mask.size
+        ret += idx[1:] - idx[:-1],
+
+    if len(ret) == 1:
+        ret = ret[0]
+    return ret
+
+
+def _unique_1d(ar, return_index=False, return_inverse=False,
+               return_counts=False, equal_nan=True):
+    ar = cupy.asarray(ar).flatten()
+
+    if return_index or return_inverse:
+        perm = ar.argsort()
+        aux = ar[perm]
+    else:
+        ar.sort()
+        aux = ar
+    mask = cupy.empty(aux.shape, dtype=cupy.bool_)
+    mask[:1] = True
+    mask[1:] = aux[1:] != aux[:-1]
+    if equal_nan:
+        _unique_update_mask_equal_nan(mask[1:], aux[:-1])
+
+    ret = aux[mask]
+    if not return_index and not return_inverse and not return_counts:
+        return ret
+
+    ret = ret,
+    if return_index:
+        ret += perm[mask],
+    if return_inverse:
+        imask = cupy.cumsum(mask) - 1
+        inv_idx = cupy.empty(mask.shape, dtype=cupy.intp)
+        inv_idx[perm] = imask
+        ret += inv_idx,
+    if return_counts:
+        nonzero = cupy.nonzero(mask)[0]  # may synchronize
+        idx = cupy.empty((nonzero.size + 1,), nonzero.dtype)
+        idx[:-1] = nonzero
+        idx[-1] = mask.size
+        ret += idx[1:] - idx[:-1],
+    return ret

vllm/lib/python3.10/site-packages/cupy/cuda/__init__.py

@@ -0,0 +1,202 @@
+import contextlib
+import warnings
+
+import cupy as _cupy
+from cupy._environment import get_cuda_path  # NOQA
+from cupy._environment import get_nvcc_path  # NOQA
+from cupy._environment import get_rocm_path  # NOQA
+from cupy._environment import get_hipcc_path  # NOQA
+from cupy.cuda import compiler  # NOQA
+from cupy.cuda import device  # NOQA
+from cupy.cuda import function  # NOQA
+from cupy.cuda import memory  # NOQA
+from cupy.cuda import memory_hook  # NOQA
+from cupy.cuda import memory_hooks  # NOQA
+from cupy.cuda import pinned_memory  # NOQA
+from cupy.cuda import profiler  # NOQA
+from cupy.cuda import stream  # NOQA
+from cupy.cuda import texture  # NOQA
+from cupy_backends.cuda.api import driver  # NOQA
+from cupy_backends.cuda.api import runtime  # NOQA
+from cupy_backends.cuda.libs import nvrtc  # NOQA
+
+
+_available = None
+
+
+class _UnavailableModule():
+    available = False
+
+    def __init__(self, name):
+        self.__name__ = name
+
+
+from cupy.cuda import cub  # NOQA
+
+
+try:
+    from cupy_backends.cuda.libs import nvtx  # NOQA
+except ImportError:
+    nvtx = _UnavailableModule('cupy.cuda.nvtx')
+
+try:
+    from cupy.cuda import thrust  # NOQA
+except ImportError:
+    thrust = _UnavailableModule('cupy.cuda.thrust')
+
+
+def __getattr__(key):
+    if key == 'cusolver':
+        from cupy_backends.cuda.libs import cusolver
+        _cupy.cuda.cusolver = cusolver
+        return cusolver
+    elif key == 'cusparse':
+        from cupy_backends.cuda.libs import cusparse
+        _cupy.cuda.cusparse = cusparse
+        return cusparse
+    elif key == 'curand':
+        from cupy_backends.cuda.libs import curand
+        _cupy.cuda.curand = curand
+        return curand
+    elif key == 'cublas':
+        from cupy_backends.cuda.libs import cublas
+        _cupy.cuda.cublas = cublas
+        return cublas
+    elif key == 'jitify':
+        if not runtime.is_hip and driver.get_build_version() > 0:
+            import cupy.cuda.jitify as jitify
+        else:
+            jitify = _UnavailableModule('cupy.cuda.jitify')
+        _cupy.cuda.jitify = jitify
+        return jitify
+
+    # `nvtx_enabled` flags are kept for backward compatibility with Chainer.
+    # Note: module-level getattr only runs on Python 3.7+.
+    for mod in [nvtx]:
+        flag = '{}_enabled'.format(mod.__name__.split('.')[-1])
+        if key == flag:
+            warnings.warn('''
+cupy.cuda.{} has been deprecated in CuPy v8 and will be removed in the future release.
+Use {}.available instead.
+                '''.format(flag, mod.__name__), DeprecationWarning)  # NOQA
+            return not isinstance(mod, _UnavailableModule)
+
+    raise AttributeError(
+        "module '{}' has no attribute '{}'".format(__name__, key))
+
+
+def is_available():
+    global _available
+    if _available is None:
+        _available = False
+        try:
+            _available = runtime.getDeviceCount() > 0
+        except Exception as e:
+            if (not runtime.is_hip and e.args[0] !=
+                    'cudaErrorNoDevice: no CUDA-capable device is detected'):
+                raise
+            elif runtime.is_hip and 'hipErrorNoDevice' not in e.args[0]:
+                raise
+    return _available
+
+
+def get_local_runtime_version() -> int:
+    """
+    Returns the version of the CUDA Runtime installed in the environment.
+
+    Unlike :func:`cupy.cuda.runtime.runtimeGetVersion`, which returns the
+    CUDA Runtime version statically linked to CuPy, this function returns the
+    version retrieved from the shared library installed on the host.
+    Use this method to probe the CUDA Runtime version installed in the
+    environment.
+    """
+    return runtime._getLocalRuntimeVersion()
+
+
+# import class and function
+from cupy.cuda.device import Device  # NOQA
+from cupy.cuda.device import get_cublas_handle  # NOQA
+from cupy.cuda.device import get_device_id  # NOQA
+from cupy.cuda.function import Function  # NOQA
+from cupy.cuda.function import Module  # NOQA
+from cupy.cuda.memory import alloc  # NOQA
+from cupy.cuda.memory import BaseMemory  # NOQA
+from cupy.cuda.memory import malloc_managed  # NOQA
+from cupy.cuda.memory import malloc_async  # NOQA
+from cupy.cuda.memory import ManagedMemory  # NOQA
+from cupy.cuda.memory import Memory  # NOQA
+from cupy.cuda.memory import MemoryAsync  # NOQA
+from cupy.cuda.memory import MemoryPointer  # NOQA
+from cupy.cuda.memory import MemoryPool  # NOQA
+from cupy.cuda.memory import MemoryAsyncPool  # NOQA
+from cupy.cuda.memory import PythonFunctionAllocator  # NOQA
+from cupy.cuda.memory import CFunctionAllocator  # NOQA
+from cupy.cuda.memory import set_allocator  # NOQA
+from cupy.cuda.memory import get_allocator  # NOQA
+from cupy.cuda.memory import UnownedMemory  # NOQA
+from cupy.cuda.memory_hook import MemoryHook  # NOQA
+from cupy.cuda.pinned_memory import alloc_pinned_memory  # NOQA
+from cupy.cuda.pinned_memory import PinnedMemory  # NOQA
+from cupy.cuda.pinned_memory import PinnedMemoryPointer  # NOQA
+from cupy.cuda.pinned_memory import PinnedMemoryPool  # NOQA
+from cupy.cuda.pinned_memory import set_pinned_memory_allocator  # NOQA
+from cupy.cuda.stream import Event  # NOQA
+from cupy.cuda.stream import get_current_stream  # NOQA
+from cupy.cuda.stream import get_elapsed_time  # NOQA
+from cupy.cuda.stream import Stream  # NOQA
+from cupy.cuda.stream import ExternalStream  # NOQA
+from cupy.cuda.graph import Graph  # NOQA
+
+
+@contextlib.contextmanager
+def using_allocator(allocator=None):
+    """Sets a thread-local allocator for GPU memory inside
+       context manager
+
+    Args:
+        allocator (function): CuPy memory allocator. It must have the same
+            interface as the :func:`cupy.cuda.alloc` function, which takes the
+            buffer size as an argument and returns the device buffer of that
+            size. When ``None`` is specified, raw memory allocator will be
+            used (i.e., memory pool is disabled).
+    """
+    # Note: cupy/memory.pyx would be the better place to implement this
+    # function but `contextmanager` decoration doesn't behave well in Cython.
+    if allocator is None:
+        allocator = memory._malloc
+    previous_allocator = memory._get_thread_local_allocator()
+    memory._set_thread_local_allocator(allocator)
+    try:
+        yield
+    finally:
+        memory._set_thread_local_allocator(previous_allocator)
+
+
+@contextlib.contextmanager
+def profile():
+    """Enable CUDA profiling during with statement.
+
+    This function enables profiling on entering a with statement, and disables
+    profiling on leaving the statement.
+
+    >>> with cupy.cuda.profile():
+    ...    # do something you want to measure
+    ...    pass
+
+    .. note::
+        When starting ``nvprof`` from the command line, manually setting
+        ``--profile-from-start off`` may be required for the desired behavior.
+
+    .. warning:: This context manager is deprecated. Please use
+        :class:`cupyx.profiler.profile` instead.
+    """
+    warnings.warn(
+        'cupy.cuda.profile has been deprecated since CuPy v10 '
+        'and will be removed in the future. Use cupyx.profiler.profile '
+        'instead.')
+
+    profiler.start()
+    try:
+        yield
+    finally:
+        profiler.stop()

vllm/lib/python3.10/site-packages/cupy/cuda/compiler.py

@@ -0,0 +1,991 @@
+import copy
+import hashlib
+import math
+import os
+import platform
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from typing import Optional
+import warnings
+
+from cupy.cuda import device
+from cupy.cuda import function
+from cupy.cuda import get_rocm_path
+from cupy_backends.cuda.api import driver
+from cupy_backends.cuda.api import runtime
+from cupy_backends.cuda.libs import nvrtc
+from cupy import _environment
+from cupy import _util
+
+_cuda_hip_version = driver.get_build_version()
+
+
+_nvrtc_version = None
+_win32 = sys.platform.startswith('win32')
+_rdc_flags = ('--device-c', '-dc', '-rdc=true',
+              '--relocatable-device-code=true')
+_cudadevrt = None
+
+
+class NVCCException(Exception):
+    pass
+
+
+class HIPCCException(Exception):
+    pass
+
+
+class JitifyException(Exception):
+    pass
+
+
+def _run_cc(cmd, cwd, backend, log_stream=None):
+    # backend in ('nvcc', 'hipcc')
+    try:
+        # Inherit the environment variable as NVCC refers to PATH, TMPDIR/TMP,
+        # NVCC_PREPEND_FLAGS, NVCC_APPEND_FLAGS.
+        env = os.environ
+        if _win32:
+            # Adds the extra PATH for NVCC invocation.
+            # When running NVCC, a host compiler must be available in PATH,
+            # but this is not true in general Windows environment unless
+            # running inside the SDK Tools command prompt.
+            # To mitigate the situation CuPy automatically adds a path to
+            # the VC++ compiler (cl.exe) found via setuptools, if it is not
+            # on the PATH.
+            extra_path = _get_extra_path_for_msvc()
+            if extra_path is not None:
+                path = extra_path + os.pathsep + os.environ.get('PATH', '')
+                env = copy.deepcopy(env)
+                env['PATH'] = path
+        log = subprocess.check_output(
+            cmd, cwd=cwd, env=env,
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+            creationflags=(subprocess.CREATE_NO_WINDOW if _win32 else 0))
+        if log_stream is not None:
+            log_stream.write(log)
+        return log
+    except subprocess.CalledProcessError as e:
+        msg = ('`{0}` command returns non-zero exit status. \n'
+               'command: {1}\n'
+               'return-code: {2}\n'
+               'stdout/stderr: \n'
+               '{3}'.format(backend,
+                            e.cmd,
+                            e.returncode,
+                            e.output))
+        if backend == 'nvcc':
+            raise NVCCException(msg)
+        elif backend == 'hipcc':
+            raise HIPCCException(msg)
+        else:
+            raise RuntimeError(msg)
+    except OSError as e:
+        msg = 'Failed to run `{0}` command. ' \
+              'Check PATH environment variable: ' \
+              + str(e)
+        raise OSError(msg.format(backend))
+
+
+@_util.memoize()
+def _get_extra_path_for_msvc():
+    cl_exe = shutil.which('cl.exe')
+    if cl_exe:
+        # The compiler is already on PATH, no extra path needed.
+        return None
+
+    cl_exe_dir = _get_cl_exe_dir()
+    if cl_exe_dir:
+        return cl_exe_dir
+
+    cl_exe_dir = _get_cl_exe_dir_fallback()
+    if cl_exe_dir:
+        return cl_exe_dir
+
+    return None
+
+
+def _get_cl_exe_dir() -> Optional[str]:
+    try:
+        try:
+            # setuptools.msvc is missing in setuptools v74.0.0.
+            # setuptools.msvc requires explicit import in setuptools v74.1.0+.
+            import setuptools.msvc
+        except Exception:
+            return None
+        vctools = setuptools.msvc.EnvironmentInfo(platform.machine()).VCTools
+        for path in vctools:
+            cl_exe = os.path.join(path, 'cl.exe')
+            if os.path.exists(cl_exe):
+                return path
+        warnings.warn(f'cl.exe could not be found in {vctools}')
+    except Exception as e:
+        warnings.warn(
+            f'Failed to find cl.exe with setuptools.msvc: {type(e)}: {e}')
+    return None
+
+
+def _get_cl_exe_dir_fallback() -> Optional[str]:
+    # Discover cl.exe without relying on undocumented setuptools.msvc API.
+    # As of now this code path exists only for setuptools 74.0.0 (see #8583).
+    # N.B. This takes few seconds as this incurs cmd.exe (vcvarsall.bat)
+    # invocation.
+    try:
+        from setuptools import Distribution
+        from setuptools.command.build_ext import build_ext
+        ext = build_ext(Distribution({'name': 'cupy_cl_exe_discover'}))
+        ext.setup_shlib_compiler()
+        ext.shlib_compiler.initialize()  # MSVCCompiler only
+        return os.path.dirname(ext.shlib_compiler.cc)
+    except Exception as e:
+        warnings.warn(
+            f'Failed to find cl.exe with setuptools: {type(e)}: {e}')
+    return None
+
+
+def _get_nvrtc_version():
+    global _nvrtc_version
+    if _nvrtc_version is None:
+        _nvrtc_version = nvrtc.getVersion()
+
+    return _nvrtc_version
+
+
+@_util.memoize()
+def _get_cupy_cache_key():
+    from cupy._core import core
+    return core.CUPY_CACHE_KEY
+
+
+# Known archs for Tegra/Jetson/Xavier/etc
+_tegra_archs = ('32', '53', '62', '72', '87')
+
+
+@_util.memoize()
+def _get_max_compute_capability():
+    major, minor = _get_nvrtc_version()
+    if major < 11:
+        # CUDA 10.2
+        nvrtc_max_compute_capability = '75'
+    elif major == 11 and minor == 0:
+        # CUDA 11.0
+        nvrtc_max_compute_capability = '80'
+    elif major == 11 and minor < 8:
+        # CUDA 11.1 - 11.7
+        # Note: 87 is for Jetson Orin
+        nvrtc_max_compute_capability = '86'
+    elif (major == 11 and minor == 8) or (major == 12 and minor < 8):
+        # CUDA 11.8, 12.0 - 12.7
+        nvrtc_max_compute_capability = '90'
+    else:
+        # CUDA 12.8+
+        nvrtc_max_compute_capability = '120'
+
+    return nvrtc_max_compute_capability
+
+
+@_util.memoize()
+def _get_extra_include_dir_opts():
+    major, minor = _get_nvrtc_version()
+    return tuple(
+        f'-I{d}'
+        for d in _environment._get_include_dir_from_conda_or_wheel(
+            major, minor
+        )
+    )
+
+
+@_util.memoize(for_each_device=True)
+def _get_arch():
+    # See Supported Compile Options section of NVRTC User Guide for
+    # the maximum value allowed for `--gpu-architecture`.
+    nvrtc_max_compute_capability = _get_max_compute_capability()
+
+    arch = device.Device().compute_capability
+    if arch in _tegra_archs:
+        return arch
+    else:
+        return min(arch, nvrtc_max_compute_capability, key=int)
+
+
+@_util.memoize(for_each_device=True)
+def _get_arch_for_options_for_nvrtc(arch=None):
+    # NVRTC in CUDA 11.3+ generates PTX that cannot be run an earlier driver
+    # version than the one included in the used CUDA version, as
+    # documented in:
+    # https://docs.nvidia.com/cuda/archive/11.3.0/nvrtc/index.html#versioning
+    # Here we use `-arch=sm_*` instead of `-arch=compute_*` to directly
+    # generate cubin (SASS) instead of PTX. See #5097 for details.
+    if arch is None:
+        arch = _get_arch()
+    if (
+        not _use_ptx
+        and int(arch) <= int(_get_max_compute_capability())
+    ):
+        return f'-arch=sm_{arch}', 'cubin'
+    return f'-arch=compute_{arch}', 'ptx'
+
+
+def _is_cudadevrt_needed(options):
+    return any(o for o in options if o in _rdc_flags)
+
+
+def _get_cudadevrt_path():
+    global _cudadevrt
+    if _cudadevrt is not None:
+        return _cudadevrt
+
+    # defer import to here to avoid circular dependency
+    from cupy.cuda import get_cuda_path
+    global _win32
+
+    cudadevrt = get_cuda_path()
+    if cudadevrt is None:
+        raise RuntimeError('CUDA is not found.')
+
+    if _win32:
+        # rely on os.altsep
+        cudadevrt += '/lib/x64/cudadevrt.lib'
+    else:  # linux & osx: search twice as in cupy/install/build.py
+        cudadevrt64 = cudadevrt + '/lib64/libcudadevrt.a'
+        if not os.path.isfile(cudadevrt64):
+            cudadevrt += '/lib/libcudadevrt.a'
+        else:
+            cudadevrt = cudadevrt64
+    if not os.path.isfile(cudadevrt):
+        raise RuntimeError(
+            'Relocatable PTX code is requested, but cudadevrt '
+            'is not found.')
+    return cudadevrt
+
+
+def _remove_rdc_option(options):
+    return tuple(o for o in options if o not in _rdc_flags)
+
+
+def _get_bool_env_variable(name, default):
+    val = os.environ.get(name)
+    if val is None or len(val) == 0:
+        return default
+    try:
+        return int(val) == 1
+    except ValueError:
+        return False
+
+
+_use_ptx = _get_bool_env_variable('CUPY_COMPILE_WITH_PTX', False)
+_jitify_header_source_map_populated = False
+
+
+def _jitify_prep(source, options, cu_path):
+    from cupy.cuda import jitify
+
+    # TODO(leofang): refactor this?
+    global _jitify_header_source_map_populated
+    if not _jitify_header_source_map_populated:
+        from cupy._core import core
+        jitify._init_module()
+        jitify._add_sources(core._get_header_source_map())
+        _jitify_header_source_map_populated = True
+
+    # jitify requires the 1st line to be the program name
+    old_source = source
+    source = cu_path + '\n' + source
+
+    # Upon failure, in addition to throw an error Jitify also prints the log
+    # to stdout. In principle we could intercept that by hijacking stdout's
+    # file descriptor (tested locally), but the problem is pytest also does
+    # the same thing internally, causing strange errors when running the tests.
+    # As a result, we currently maintain Jitify's default behavior for easy
+    # debugging, and wait for the upstream to address this issue
+    # (NVIDIA/jitify#79).
+
+    try:
+        name, options, headers, include_names = jitify.jitify(source, options)
+    except Exception as e:  # C++ could throw all kinds of errors
+        cex = CompileException(str(e), old_source, cu_path, options, 'jitify')
+        dump = _get_bool_env_variable(
+            'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+        if dump:
+            cex.dump(sys.stderr)
+        raise JitifyException(str(cex)) from e
+    assert name == cu_path
+
+    return options, headers, include_names
+
+
+_has_usedforsecurity = (sys.version_info >= (3, 9))
+
+
+def _hash_hexdigest(value):
+    if _has_usedforsecurity:
+        hashobj = hashlib.sha1(value, usedforsecurity=False)
+    else:
+        hashobj = hashlib.sha1(value)
+    return hashobj.hexdigest()
+
+
+_hash_length = len(_hash_hexdigest(b''))  # 40 for SHA1
+
+
+def compile_using_nvrtc(source, options=(), arch=None, filename='kern.cu',
+                        name_expressions=None, log_stream=None,
+                        cache_in_memory=False, jitify=False):
+    def _compile(
+            source, options, cu_path, name_expressions, log_stream, jitify):
+
+        if not runtime.is_hip:
+            arch_opt, method = _get_arch_for_options_for_nvrtc(arch)
+            options += (arch_opt,)
+        else:
+            method = 'ptx'
+
+        if jitify:
+            options, headers, include_names = _jitify_prep(
+                source, options, cu_path)
+        else:
+            headers = include_names = ()
+            major_version, minor_version = _get_nvrtc_version()
+            if major_version >= 12:
+                # Starting with CUDA 12.0, even without using jitify, some
+                # tests cause an error if the following option is not included.
+                options += ('--device-as-default-execution-space',)
+
+        prog = _NVRTCProgram(source, cu_path, headers, include_names,
+                             name_expressions=name_expressions, method=method)
+        try:
+            compiled_obj, mapping = prog.compile(options, log_stream)
+        except CompileException as e:
+            dump = _get_bool_env_variable(
+                'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+            if dump:
+                e.dump(sys.stderr)
+            raise
+        return compiled_obj, mapping
+
+    if not cache_in_memory:
+        with tempfile.TemporaryDirectory() as root_dir:
+            cu_path = os.path.join(root_dir, filename)
+
+            with open(cu_path, 'w') as cu_file:
+                cu_file.write(source)
+
+            return _compile(source, options, cu_path,
+                            name_expressions, log_stream, jitify)
+    else:
+        cu_path = '' if not jitify else filename
+        return _compile(source, options, cu_path, name_expressions,
+                        log_stream, jitify)
+
+
+def compile_using_nvcc(source, options=(), arch=None,
+                       filename='kern.cu', code_type='cubin',
+                       separate_compilation=False, log_stream=None):
+    # defer import to here to avoid circular dependency
+    from cupy.cuda import get_nvcc_path
+
+    if not arch:
+        arch = _get_arch()
+
+    if code_type not in ('cubin', 'ptx'):
+        raise ValueError('Invalid code_type %s. Should be cubin or ptx')
+    if code_type == 'ptx':
+        assert not separate_compilation
+
+    arch_str = '-gencode=arch=compute_{cc},code=sm_{cc}'.format(cc=arch)
+    _nvcc = get_nvcc_path()
+    # split() is needed because _nvcc could come from the env var NVCC
+    cmd = _nvcc.split()
+    cmd.append(arch_str)
+
+    with tempfile.TemporaryDirectory() as root_dir:
+        first_part = filename.split('.')[0]
+
+        path = os.path.join(root_dir, first_part)
+        cu_path = '%s.cu' % path
+        result_path = '%s.%s' % (path, code_type)
+
+        with open(cu_path, 'w') as cu_file:
+            cu_file.write(source)
+
+        if not separate_compilation:  # majority cases
+            cmd.append('--%s' % code_type)
+            cmd += list(options)
+            cmd.append(cu_path)
+
+            try:
+                _run_cc(cmd, root_dir, 'nvcc', log_stream)
+            except NVCCException as e:
+                cex = CompileException(str(e), source, cu_path, options,
+                                       'nvcc')
+
+                dump = _get_bool_env_variable(
+                    'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+                if dump:
+                    cex.dump(sys.stderr)
+
+                raise cex
+        else:  # two steps: compile to object and device-link
+            cmd_partial = cmd.copy()
+            cmd_partial.append('--cubin')
+
+            obj = path + '.o'
+            cmd += list(options + ('-o', obj))
+            cmd.append(cu_path)
+
+            try:
+                _run_cc(cmd, root_dir, 'nvcc', log_stream)
+            except NVCCException as e:
+                cex = CompileException(str(e), source, cu_path, options,
+                                       'nvcc')
+
+                dump = _get_bool_env_variable(
+                    'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+                if dump:
+                    cex.dump(sys.stderr)
+
+                raise cex
+
+            options = _remove_rdc_option(options)
+            options += ('--device-link', obj, '-o', path + '.cubin')
+            cmd = cmd_partial + list(options)
+
+            try:
+                _run_cc(cmd, root_dir, 'nvcc', log_stream)
+            except NVCCException as e:
+                cex = CompileException(str(e), '', '', options, 'nvcc')
+                raise cex
+
+        if code_type == 'ptx':
+            with open(result_path, 'rb') as ptx_file:
+                return ptx_file.read()
+        elif code_type == 'cubin':
+            with open(result_path, 'rb') as bin_file:
+                return bin_file.read()
+        else:
+            assert False, code_type
+
+
+def _preprocess(source, options, arch, backend):
+    if backend == 'nvrtc':
+        # For the preprocess it is enough to use PTX method
+        # we don't need to explicitly obtain a CUBIN file.
+        options += ('-arch=compute_{}'.format(arch),)
+        prog = _NVRTCProgram(source)
+        try:
+            result, _ = prog.compile(options)
+        except CompileException as e:
+            dump = _get_bool_env_variable(
+                'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+            if dump:
+                e.dump(sys.stderr)
+            raise
+    elif backend == 'nvcc':
+        try:
+            result = compile_using_nvcc(source, options, arch, 'preprocess.cu',
+                                        code_type='ptx')
+        except CompileException as e:
+            dump = _get_bool_env_variable(
+                'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+            if dump:
+                e.dump(sys.stderr)
+            raise
+    else:
+        raise ValueError('Invalid backend %s' % backend)
+
+    assert isinstance(result, bytes)
+
+    # Extract the part containing version information.
+    return '\n'.join(
+        x for x in result.decode().splitlines() if x.startswith('//'))
+
+
+_default_cache_dir = os.path.expanduser('~/.cupy/kernel_cache')
+
+
+def get_cache_dir():
+    return os.environ.get('CUPY_CACHE_DIR', _default_cache_dir)
+
+
+_empty_file_preprocess_cache: dict = {}
+
+
+def _compile_module_with_cache(
+        source, options=(), arch=None, cache_dir=None, extra_source=None,
+        backend='nvrtc', *, enable_cooperative_groups=False,
+        name_expressions=None, log_stream=None, jitify=False):
+
+    if enable_cooperative_groups:
+        if runtime.is_hip:
+            raise ValueError(
+                'Cooperative groups is not supported in HIP.')
+
+    if name_expressions is not None and backend != 'nvrtc':
+        raise NotImplementedError
+
+    # We silently ignore CUPY_CACHE_IN_MEMORY if nvcc/hipcc are in use, because
+    # they must dump files to disk.
+    cache_in_memory = (
+        _get_bool_env_variable('CUPY_CACHE_IN_MEMORY', False)
+        and backend == 'nvrtc')
+
+    if runtime.is_hip:
+        backend = 'hiprtc' if backend == 'nvrtc' else 'hipcc'
+        return _compile_with_cache_hip(
+            source, options, arch, cache_dir, extra_source, backend,
+            name_expressions, log_stream, cache_in_memory)
+    else:
+        return _compile_with_cache_cuda(
+            source, options, arch, cache_dir, extra_source, backend,
+            enable_cooperative_groups, name_expressions, log_stream,
+            cache_in_memory, jitify)
+
+
+def _compile_with_cache_cuda(
+        source, options, arch, cache_dir, extra_source=None, backend='nvrtc',
+        enable_cooperative_groups=False, name_expressions=None,
+        log_stream=None, cache_in_memory=False, jitify=False):
+    # NVRTC does not use extra_source. extra_source is used for cache key.
+    global _empty_file_preprocess_cache
+    if cache_dir is None:
+        cache_dir = get_cache_dir()
+    if arch is None:
+        arch = _get_arch()
+
+    options += ('-ftz=true',)
+
+    if enable_cooperative_groups:
+        # `cooperative_groups` requires relocatable device code.
+        options += ('--device-c',)
+
+    if _get_bool_env_variable('CUPY_CUDA_COMPILE_WITH_DEBUG', False):
+        options += ('--device-debug', '--generate-line-info')
+
+    is_jitify_requested = ('-DCUPY_USE_JITIFY' in options)
+    if jitify and not is_jitify_requested:
+        # jitify is set in RawKernel/RawModule, translate it to an option
+        # that is useless to the compiler, but can be used as part of the
+        # hash key
+        options += ('-DCUPY_USE_JITIFY',)
+    elif is_jitify_requested and not jitify:
+        # jitify is requested internally, just set the flag
+        jitify = True
+    if jitify and backend != 'nvrtc':
+        raise ValueError('jitify only works with NVRTC')
+
+    options += _get_extra_include_dir_opts()
+    env = ((arch, options, _get_nvrtc_version(), backend)
+           + _get_arch_for_options_for_nvrtc(arch))
+    base = _empty_file_preprocess_cache.get(env, None)
+    if base is None:
+        # This is for checking NVRTC/NVCC compiler internal version
+        base = _preprocess('', options, arch, backend)
+        _empty_file_preprocess_cache[env] = base
+
+    key_src = '%s %s %s %s %s' % (
+        env, base, source, extra_source, _get_cupy_cache_key())
+    key_src = key_src.encode('utf-8')
+    name = _hash_hexdigest(key_src) + '.cubin'
+
+    mod = function.Module()
+
+    if not cache_in_memory:
+        # Read from disk cache
+        if not os.path.isdir(cache_dir):
+            os.makedirs(cache_dir, exist_ok=True)
+
+        # To handle conflicts in concurrent situation, we adopt lock-free
+        # method to avoid performance degradation.
+        # We force recompiling to retrieve C++ mangled names if so desired.
+        path = os.path.join(cache_dir, name)
+        if os.path.exists(path) and not name_expressions:
+            with open(path, 'rb') as file:
+                data = file.read()
+            if len(data) >= _hash_length:
+                hash = data[:_hash_length]
+                cubin = data[_hash_length:]
+                cubin_hash = _hash_hexdigest(cubin).encode('ascii')
+                if hash == cubin_hash:
+                    mod.load(cubin)
+                    return mod
+    else:
+        # Enforce compiling -- the resulting kernel will be cached elsewhere,
+        # so we do nothing
+        pass
+
+    if backend == 'nvrtc':
+        cu_name = '' if cache_in_memory else name + '.cu'
+        ptx, mapping = compile_using_nvrtc(
+            source, options, arch, cu_name, name_expressions,
+            log_stream, cache_in_memory, jitify)
+        if _is_cudadevrt_needed(options):
+            # for separate compilation
+            ls = function.LinkState()
+            ls.add_ptr_data(ptx, 'cupy.ptx')
+            _cudadevrt = _get_cudadevrt_path()
+            ls.add_ptr_file(_cudadevrt)
+            cubin = ls.complete()
+        else:
+            cubin = ptx
+        mod._set_mapping(mapping)
+    elif backend == 'nvcc':
+        rdc = _is_cudadevrt_needed(options)
+        cubin = compile_using_nvcc(source, options, arch,
+                                   name + '.cu', code_type='cubin',
+                                   separate_compilation=rdc,
+                                   log_stream=log_stream)
+    else:
+        raise ValueError('Invalid backend %s' % backend)
+
+    if not cache_in_memory:
+        # Write to disk cache
+        cubin_hash = _hash_hexdigest(cubin).encode('ascii')
+
+        # shutil.move is not atomic operation, so it could result in a
+        # corrupted file. We detect it by appending a hash at the beginning
+        # of each cache file. If the file is corrupted, it will be ignored
+        # next time it is read.
+        with tempfile.NamedTemporaryFile(dir=cache_dir, delete=False) as tf:
+            tf.write(cubin_hash)
+            tf.write(cubin)
+            temp_path = tf.name
+        shutil.move(temp_path, path)
+
+        # Save .cu source file along with .cubin
+        if _get_bool_env_variable('CUPY_CACHE_SAVE_CUDA_SOURCE', False):
+            with open(path + '.cu', 'w') as f:
+                f.write(source)
+    else:
+        # we don't do any disk I/O
+        pass
+
+    mod.load(cubin)
+    return mod
+
+
+class CompileException(Exception):
+
+    def __init__(self, msg, source, name, options, backend='nvrtc'):
+        self._msg = msg
+        self.source = source
+        self.name = name
+        self.options = options
+        self.backend = backend
+        super(CompileException, self).__init__()
+
+    def __reduce__(self):
+        return (type(self), (self._msg, self.source, self.name,
+                             self.options, self.backend))
+
+    def __repr__(self):
+        return str(self)
+
+    def __str__(self):
+        return self.get_message()
+
+    def get_message(self):
+        return self._msg
+
+    def dump(self, f):
+        lines = self.source.split('\n')
+        digits = int(math.floor(math.log10(len(lines)))) + 1
+        linum_fmt = '{{:0{}d}} '.format(digits)
+        f.write('{} '.format(self.backend.upper()))
+        f.write('compilation error: {}\n'.format(self))
+        f.write('-----\n')
+        f.write('Name: {}\n'.format(self.name))
+        f.write('Options: {}\n'.format(' '.join(self.options)))
+        f.write('CUDA source:\n')
+        for i, line in enumerate(lines):
+            f.write(linum_fmt.format(i + 1) + line.rstrip() + '\n')
+        f.write('-----\n')
+        f.flush()
+
+
+class _NVRTCProgram(object):
+
+    def __init__(self, src, name='default_program', headers=(),
+                 include_names=(), name_expressions=None, method='ptx'):
+        self.ptr = None
+
+        if isinstance(src, bytes):
+            src = src.decode('UTF-8')
+        if isinstance(name, bytes):
+            name = name.decode('UTF-8')
+
+        self.src = src
+        self.name = name
+        self.ptr = nvrtc.createProgram(src, name, headers, include_names)
+        self.name_expressions = name_expressions
+        self.method = method
+
+    def __del__(self, is_shutting_down=_util.is_shutting_down):
+        if is_shutting_down():
+            return
+        if self.ptr:
+            nvrtc.destroyProgram(self.ptr)
+
+    def compile(self, options=(), log_stream=None):
+        try:
+            if self.name_expressions:
+                for ker in self.name_expressions:
+                    nvrtc.addNameExpression(self.ptr, ker)
+            nvrtc.compileProgram(self.ptr, options)
+            mapping = None
+            if self.name_expressions:
+                mapping = {}
+                for ker in self.name_expressions:
+                    mapping[ker] = nvrtc.getLoweredName(self.ptr, ker)
+            if log_stream is not None:
+                log_stream.write(nvrtc.getProgramLog(self.ptr))
+            # This is to ensure backwards compatibility with nvrtc
+            if self.method == 'cubin':
+                return nvrtc.getCUBIN(self.ptr), mapping
+            elif self.method == 'ptx':
+                return nvrtc.getPTX(self.ptr), mapping
+            # TODO(leofang): support JIT LTO using nvrtc.getNVVM()?
+            # need -dlto and -arch=compute_XX
+            else:
+                raise RuntimeError('Unknown NVRTC compile method')
+        except nvrtc.NVRTCError:
+            log = nvrtc.getProgramLog(self.ptr)
+            raise CompileException(log, self.src, self.name, options,
+                                   'nvrtc' if not runtime.is_hip else 'hiprtc')
+
+
+def is_valid_kernel_name(name):
+    return re.match('^[a-zA-Z_][a-zA-Z_0-9]*$', name) is not None
+
+
+def compile_using_hipcc(source, options, arch, log_stream=None):
+    # As of ROCm 3.5.0 hiprtc/hipcc can automatically pick up the
+    # right arch without setting HCC_AMDGPU_TARGET, so we don't need
+    # to set arch here
+    cmd = ['hipcc', '--genco'] + list(options)
+
+    with tempfile.TemporaryDirectory() as root_dir:
+        path = os.path.join(root_dir, 'kern')
+        in_path = path + '.cpp'
+        out_path = path + '.hsaco'
+
+        with open(in_path, 'w') as f:
+            f.write(source)
+
+        cmd += [in_path, '-o', out_path]
+
+        try:
+            output = _run_cc(cmd, root_dir, 'hipcc', log_stream)
+        except HIPCCException as e:
+            cex = CompileException(str(e), source, in_path, options,
+                                   'hipcc')
+
+            dump = _get_bool_env_variable(
+                'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+            if dump:
+                cex.dump(sys.stderr)
+
+            raise cex
+        if not os.path.isfile(out_path):
+            raise HIPCCException(
+                '`hipcc` command does not generate output file. \n'
+                'command: {0}\n'
+                'stdout/stderr: \n'
+                '{1}'.format(cmd, output))
+        with open(out_path, 'rb') as f:
+            return f.read()
+
+
+# TODO(leofang): consider merge _preprocess_hipcc with _preprocess_hiprtc,
+# perhaps also with _preprocess?
+def _preprocess_hipcc(source, options):
+    cmd = ['hipcc', '--preprocess'] + list(options)
+    with tempfile.TemporaryDirectory() as root_dir:
+        path = os.path.join(root_dir, 'kern')
+        cu_path = '%s.cpp' % path
+
+        with open(cu_path, 'w') as cu_file:
+            cu_file.write(source)
+
+        cmd.append(cu_path)
+        pp_src = _run_cc(cmd, root_dir, 'hipcc')
+        assert isinstance(pp_src, str)
+        return re.sub('(?m)^#.*$', '', pp_src)
+
+
+def _preprocess_hiprtc(source, options):
+    # source is ignored
+    if _cuda_hip_version >= 40400000:
+        # HIP runtime headers can be no longer explicitly included on ROCm 4.5+
+        code = '''
+        // hiprtc segfaults if the input code is empty
+        __global__ void _cupy_preprocess_dummy_kernel_() { }
+        '''
+    else:
+        code = '''
+        // hiprtc segfaults if the input code is empty
+        #include <hip/hip_runtime.h>
+        __global__ void _cupy_preprocess_dummy_kernel_() { }
+        '''
+
+    prog = _NVRTCProgram(code)
+    try:
+        result, _ = prog.compile(options)
+    except CompileException as e:
+        dump = _get_bool_env_variable(
+            'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+        if dump:
+            e.dump(sys.stderr)
+        raise
+    assert isinstance(result, bytes)
+    return result
+
+
+_hip_extra_source = None
+
+
+def _convert_to_hip_source(source, extra_source, is_hiprtc):
+    if not is_hiprtc:
+        return '#include <hip/hip_runtime.h>\n' + source
+    if _cuda_hip_version >= 40400000:
+        # HIP runtime headers can be no longer explicitly included on ROCm 4.5+
+        return source
+    if _cuda_hip_version >= 402:
+        # "-I" is fixed on ROCm 4.2.0+
+        return '#include <hip/hip_runtime.h>\n' + source
+
+    # Workaround for hiprtc: it does not follow the -I option to search
+    # headers (as of ROCm 3.5.0), so we must prepend all CuPy's headers
+    global _hip_extra_source
+    if _hip_extra_source is None:
+        if extra_source is not None:
+            extra_source = extra_source.split('\n')
+            extra_source = [line for line in extra_source if (
+                not line.startswith('#include')
+                and not line.startswith('#pragma once'))]
+            _hip_extra_source = extra_source = '\n'.join(extra_source)
+
+    source = source.split('\n')
+    source = [line for line in source if not line.startswith('#include')]
+    source = ('#include <hip/hip_runtime.h>\n#include <hip/hip_fp16.h>\n'
+              + _hip_extra_source + '\n'.join(source))
+
+    return source
+
+
+# TODO(leofang): evaluate if this can be merged with _compile_with_cache_cuda()
+def _compile_with_cache_hip(source, options, arch, cache_dir, extra_source,
+                            backend='hiprtc', name_expressions=None,
+                            log_stream=None, cache_in_memory=False,
+                            use_converter=True):
+    global _empty_file_preprocess_cache
+
+    # TODO(leofang): this might be possible but is currently undocumented
+    if _is_cudadevrt_needed(options):
+        raise ValueError('separate compilation is not supported in HIP')
+
+    # HIP's equivalent of -ftz=true, see ROCm-Developer-Tools/HIP#2252
+    # Notes:
+    # - For hipcc, this should just work, as invalid options would cause errors
+    #   See https://clang.llvm.org/docs/ClangCommandLineReference.html.
+    # - For hiprtc, this is a no-op until the compiler options like -D and -I
+    #   are accepted, see ROCm-Developer-Tools/HIP#2182 and
+    #   ROCm-Developer-Tools/HIP#2248
+    options += ('-fcuda-flush-denormals-to-zero',)
+
+    # Workaround ROCm 4.3 LLVM_PATH issue in hipRTC #5689
+    rocm_build_version = driver.get_build_version()
+    if rocm_build_version >= 40300000 and rocm_build_version < 40500000:
+        options += (
+            '-I' + get_rocm_path() + '/llvm/lib/clang/13.0.0/include/',)
+
+    if cache_dir is None:
+        cache_dir = get_cache_dir()
+    # As of ROCm 3.5.0 hiprtc/hipcc can automatically pick up the
+    # right arch without setting HCC_AMDGPU_TARGET, so we don't need
+    # to tell the compiler which arch we are targeting. But, we still
+    # need to know arch as part of the cache key:
+    if arch is None:
+        # On HIP, gcnArch is computed from "compute capability":
+        # https://github.com/ROCm-Developer-Tools/HIP/blob/rocm-4.0.0/rocclr/hip_device.cpp#L202
+        arch = device.Device().compute_capability
+    if use_converter:
+        source = _convert_to_hip_source(source, extra_source,
+                                        is_hiprtc=(backend == 'hiprtc'))
+
+    env = (arch, options, _get_nvrtc_version(), backend)
+    base = _empty_file_preprocess_cache.get(env, None)
+    if base is None:
+        # This is for checking HIPRTC/HIPCC compiler internal version
+        if backend == 'hiprtc':
+            base = _preprocess_hiprtc('', options)
+        else:
+            base = _preprocess_hipcc('', options)
+        _empty_file_preprocess_cache[env] = base
+
+    key_src = '%s %s %s %s' % (env, base, source, extra_source)
+    key_src = key_src.encode('utf-8')
+    name = _hash_hexdigest(key_src) + '.hsaco'
+
+    mod = function.Module()
+
+    if not cache_in_memory:
+        # Read from disk cache
+        if not os.path.isdir(cache_dir):
+            os.makedirs(cache_dir, exist_ok=True)
+
+        # To handle conflicts in concurrent situation, we adopt lock-free
+        # method to avoid performance degradation.
+        # We force recompiling to retrieve C++ mangled names if so desired.
+        path = os.path.join(cache_dir, name)
+        if os.path.exists(path) and not name_expressions:
+            with open(path, 'rb') as f:
+                data = f.read()
+            if len(data) >= _hash_length:
+                hash_value = data[:_hash_length]
+                binary = data[_hash_length:]
+                binary_hash = _hash_hexdigest(binary).encode('ascii')
+                if hash_value == binary_hash:
+                    mod.load(binary)
+                    return mod
+    else:
+        # Enforce compiling -- the resulting kernel will be cached elsewhere,
+        # so we do nothing
+        pass
+
+    if backend == 'hiprtc':
+        # compile_using_nvrtc calls hiprtc for hip builds
+        binary, mapping = compile_using_nvrtc(
+            source, options, arch, name + '.cu', name_expressions,
+            log_stream, cache_in_memory)
+        mod._set_mapping(mapping)
+    else:
+        binary = compile_using_hipcc(source, options, arch, log_stream)
+
+    if not cache_in_memory:
+        # Write to disk cache
+        binary_hash = _hash_hexdigest(binary).encode('ascii')
+
+        # shutil.move is not atomic operation, so it could result in a
+        # corrupted file. We detect it by appending a hash at the beginning
+        # of each cache file. If the file is corrupted, it will be ignored
+        # next time it is read.
+        with tempfile.NamedTemporaryFile(dir=cache_dir, delete=False) as tf:
+            tf.write(binary_hash)
+            tf.write(binary)
+            temp_path = tf.name
+        shutil.move(temp_path, path)
+
+        # Save .cu source file along with .hsaco
+        if _get_bool_env_variable('CUPY_CACHE_SAVE_CUDA_SOURCE', False):
+            with open(path + '.cpp', 'w') as f:
+                f.write(source)
+    else:
+        # we don't do any disk I/O
+        pass
+
+    mod.load(binary)
+    return mod

vllm/lib/python3.10/site-packages/cupy/cuda/cudnn.py

@@ -0,0 +1,17 @@
+"""
+cuDNN Wrapper
+
+Use `cupy_backends.cuda.libs.cudnn` directly in CuPy codebase.
+"""
+
+from cupy import _environment
+
+
+available = True
+
+try:
+    _environment._preload_library('cudnn')
+    from cupy_backends.cuda.libs.cudnn import *  # NOQA
+except ImportError as e:
+    available = False
+    _environment._preload_warning('cudnn', e)

vllm/lib/python3.10/site-packages/cupy/cuda/cufft.pxd

@@ -0,0 +1,99 @@
+# Note: nothing exposed in this pxd header is considered public API;
+# we copy this to sdist only because it's needed at runtime to support
+# cuFFT callbacks
+
+from libc.stdint cimport intptr_t
+
+cdef extern from *:
+    ctypedef float Float 'cufftReal'
+    ctypedef double Double 'cufftDoubleReal'
+    ctypedef int Result 'cufftResult_t'
+
+    IF CUPY_HIP_VERSION > 0:
+        ctypedef int Handle 'cufftHandle'
+    ELSE:
+        ctypedef struct hipHandle 'hipfftHandle_t':
+            pass
+        ctypedef hipHandle* Handle 'cufftHandle'
+
+    ctypedef enum Type 'cufftType_t':
+        pass
+
+
+cpdef enum:
+    CUFFT_C2C = 0x29
+    CUFFT_R2C = 0x2a
+    CUFFT_C2R = 0x2c
+    CUFFT_Z2Z = 0x69
+    CUFFT_D2Z = 0x6a
+    CUFFT_Z2D = 0x6c
+
+    CUFFT_FORWARD = -1
+    CUFFT_INVERSE = 1
+
+    CUFFT_CB_LD_COMPLEX = 0x0,
+    CUFFT_CB_LD_COMPLEX_DOUBLE = 0x1,
+    CUFFT_CB_LD_REAL = 0x2,
+    CUFFT_CB_LD_REAL_DOUBLE = 0x3,
+    CUFFT_CB_ST_COMPLEX = 0x4,
+    CUFFT_CB_ST_COMPLEX_DOUBLE = 0x5,
+    CUFFT_CB_ST_REAL = 0x6,
+    CUFFT_CB_ST_REAL_DOUBLE = 0x7,
+
+
+cpdef get_current_plan()
+cpdef int getVersion() except? -1
+
+
+cdef class Plan1d:
+    cdef:
+        readonly intptr_t handle
+        readonly object work_area  # can be MemoryPointer or a list of it
+        readonly int nx
+        readonly int batch
+        readonly Type fft_type
+
+        readonly list gpus
+        list batch_share
+        list gather_streams
+        list gather_events
+        dict scatter_streams
+        dict scatter_events
+        intptr_t xtArr
+        list xtArr_buffer
+
+        void _single_gpu_get_plan(
+            self, Handle plan, int nx, int fft_type, int batch) except*
+        void _multi_gpu_get_plan(
+            self, Handle plan, int nx, int fft_type, int batch,
+            devices, out) except*
+
+
+cdef class PlanNd:
+    cdef:
+        readonly intptr_t handle
+        readonly object work_area  # memory.MemoryPointer
+        readonly tuple shape
+        readonly Type fft_type
+        readonly str order
+        readonly int last_axis
+        readonly object last_size
+
+        # TODO(leofang): support multi-GPU transforms
+        readonly list gpus
+
+
+cdef class XtPlanNd:
+    cdef:
+        readonly intptr_t handle
+        readonly object work_area  # memory.MemoryPointer
+        readonly tuple shape
+        readonly int itype
+        readonly int otype
+        readonly int etype
+        readonly str order
+        readonly int last_axis
+        readonly object last_size
+
+        # TODO(leofang): support multi-GPU transforms
+        readonly list gpus

vllm/lib/python3.10/site-packages/cupy/cuda/cufft.pyx

@@ -0,0 +1,1205 @@
+cimport cython  # NOQA
+from cpython.mem cimport PyMem_Malloc, PyMem_Free
+from libc.string cimport memset as c_memset
+from libcpp cimport vector
+
+import numpy
+import threading
+
+import cupy
+from cupy.cuda import device
+from cupy.cuda import memory
+from cupy.cuda import runtime
+from cupy.cuda import stream
+
+
+cdef object _thread_local = threading.local()
+
+
+cpdef get_current_plan():
+    """Get current cuFFT plan.
+
+    Returns:
+        None or cupy.cuda.cufft.Plan1d or cupy.cuda.cufft.PlanNd
+    """
+    if not hasattr(_thread_local, '_current_plan'):
+        _thread_local._current_plan = None
+    return _thread_local._current_plan
+
+
+cdef enum:
+    # Actually, this is 64, but it's undocumented. For the sake
+    # of safety, let us use 16, which agrees with the cuFFT doc.
+    MAX_CUDA_DESCRIPTOR_GPUS = 16
+
+
+cdef extern from 'cupy_cufft.h' nogil:
+    # we duplicate some types here to avoid cimporting from driver/runtime,
+    # as we don't include their .pxd files in the sdist
+    ctypedef void* Stream 'cudaStream_t'
+    ctypedef int DataType 'cudaDataType'
+
+    ctypedef struct Complex 'cufftComplex':
+        float x, y
+    ctypedef struct DoubleComplex 'cufftDoubleComplex':
+        double x, y
+
+    # cuFFT Helper Function
+    Result cufftCreate(Handle *plan)
+    Result cufftDestroy(Handle plan)
+    Result cufftSetAutoAllocation(Handle plan, int autoAllocate)
+    Result cufftSetWorkArea(Handle plan, void *workArea)
+
+    # cuFFT Stream Function
+    Result cufftSetStream(Handle plan, Stream streamId)
+
+    # cuFFT Plan Functions
+    Result cufftMakePlan1d(Handle plan, int nx, Type type, int batch,
+                           size_t *workSize)
+    Result cufftMakePlanMany(Handle plan, int rank, int *n, int *inembed,
+                             int istride, int idist, int *onembed, int ostride,
+                             int odist, Type type, int batch,
+                             size_t *workSize)
+
+    # cuFFT Exec Function
+    Result cufftExecC2C(Handle plan, Complex *idata, Complex *odata,
+                        int direction)
+    Result cufftExecR2C(Handle plan, Float *idata, Complex *odata)
+    Result cufftExecC2R(Handle plan, Complex *idata, Float *odata)
+    Result cufftExecZ2Z(Handle plan, DoubleComplex *idata,
+                        DoubleComplex *odata, int direction)
+    Result cufftExecD2Z(Handle plan, Double *idata, DoubleComplex *odata)
+    Result cufftExecZ2D(Handle plan, DoubleComplex *idata, Double *odata)
+
+    # Version
+    Result cufftGetVersion(int* version)
+
+    # cufftXt data types
+    ctypedef struct XtArrayDesc 'cudaXtDesc':
+        int version
+        int nGPUs
+        int GPUs[MAX_CUDA_DESCRIPTOR_GPUS]
+        void* data[MAX_CUDA_DESCRIPTOR_GPUS]
+        size_t size[MAX_CUDA_DESCRIPTOR_GPUS]
+        void* cudaXtState
+
+    ctypedef enum XtSubFormat 'cufftXtSubFormat':
+        CUFFT_XT_FORMAT_INPUT
+        CUFFT_XT_FORMAT_OUTPUT
+        CUFFT_XT_FORMAT_INPLACE
+        CUFFT_XT_FORMAT_INPLACE_SHUFFLED
+        CUFFT_XT_FORMAT_1D_INPUT_SHUFFLED
+
+    ctypedef struct XtArray 'cudaLibXtDesc':
+        int version
+        XtArrayDesc* descriptor
+        int library
+        XtSubFormat subFormat
+        void* libDescriptor
+
+    ctypedef enum XtCopyType 'cufftXtCopyType':
+        CUFFT_COPY_HOST_TO_DEVICE = 0x00
+        CUFFT_COPY_DEVICE_TO_HOST = 0x01
+        CUFFT_COPY_DEVICE_TO_DEVICE = 0x02
+
+    # cufftXt functions
+    Result cufftXtSetGPUs(Handle plan, int nGPUs, int* gpus)
+    Result cufftXtSetWorkArea(Handle plan, void** workArea)
+    Result cufftXtMemcpy(Handle plan, void *dst, void *src, XtCopyType type)
+    Result cufftXtExecDescriptorC2C(Handle plan, XtArray* idata,
+                                    XtArray* odata, int direction)
+    Result cufftXtExecDescriptorZ2Z(Handle plan, XtArray* idata,
+                                    XtArray* odata, int direction)
+    Result cufftXtMakePlanMany(Handle plan, int rank, long long int* n,
+                               long long int* inembed,
+                               long long int istride,
+                               long long int idist,
+                               DataType inputtype,
+                               long long int* onembed,
+                               long long int ostride,
+                               long long int odist,
+                               DataType outputtype,
+                               long long int batch, size_t* workSize,
+                               DataType executiontype)
+    Result cufftXtExec(Handle plan, void* inarr, void* outarr, int d)
+
+
+IF CUPY_CUFFT_STATIC:
+    # cuFFT callback
+    cdef extern from 'cupy_cufftXt.h' nogil:
+        ctypedef enum callbackType 'cufftXtCallbackType':
+            pass
+        Result set_callback(Handle, callbackType, bint, void**)
+
+
+cdef dict RESULT = {
+    0: 'CUFFT_SUCCESS',
+    1: 'CUFFT_INVALID_PLAN',
+    2: 'CUFFT_ALLOC_FAILED',
+    3: 'CUFFT_INVALID_TYPE',
+    4: 'CUFFT_INVALID_VALUE',
+    5: 'CUFFT_INTERNAL_ERROR',
+    6: 'CUFFT_EXEC_FAILED',
+    7: 'CUFFT_SETUP_FAILED',
+    8: 'CUFFT_INVALID_SIZE',
+    9: 'CUFFT_UNALIGNED_DATA',
+    10: 'CUFFT_INCOMPLETE_PARAMETER_LIST',
+    11: 'CUFFT_INVALID_DEVICE',
+    12: 'CUFFT_PARSE_ERROR',
+    13: 'CUFFT_NO_WORKSPACE',
+    14: 'CUFFT_NOT_IMPLEMENTED',
+    15: 'CUFFT_LICENSE_ERROR',
+    16: 'CUFFT_NOT_SUPPORTED',
+}
+
+
+class CuFFTError(RuntimeError):
+
+    def __init__(self, int result):
+        self.result = result
+        super(CuFFTError, self).__init__('%s' % (RESULT[result]))
+
+    def __reduce__(self):
+        return (type(self), (self.result,))
+
+
+@cython.profile(False)
+cpdef inline void check_result(int result) except *:
+    if result != 0:
+        raise CuFFTError(result)
+
+
+cpdef int getVersion() except? -1:
+    cdef int version, result
+    result = cufftGetVersion(&version)
+    check_result(result)
+    return version
+
+
+# This is necessary for single-batch transforms: "when batch is one, data is
+# left in the GPU memory in a permutation of the natural output", see
+# https://docs.nvidia.com/cuda/cufft/index.html#multiple-GPU-cufft-intermediate-helper  # NOQA
+cdef _reorder_buffers(Handle plan, intptr_t xtArr, list xtArr_buffer):
+    cdef int i, result, nGPUs
+    cdef intptr_t temp_xtArr
+    cdef XtArray* temp_arr
+    cdef XtArray* arr
+    cdef list gpus = []
+    cdef list sizes = []
+    cdef list temp_xtArr_buffer
+
+    arr = <XtArray*>xtArr
+    nGPUs = len(xtArr_buffer)
+    assert nGPUs == arr.descriptor.nGPUs
+
+    # allocate another buffer to prepare for order conversion
+    for i in range(nGPUs):
+        gpus.append(arr.descriptor.GPUs[i])
+        sizes.append(arr.descriptor.size[i])
+    temp_xtArr, temp_xtArr_buffer = _XtMalloc(gpus, sizes,
+                                              CUFFT_XT_FORMAT_INPLACE)
+    temp_arr = <XtArray*>temp_xtArr
+
+    # Make a device copy to bring the data from the permuted order back to
+    # the natural order. Note that this works because after FFT
+    # arr.subFormat is silently changed to CUFFT_XT_FORMAT_INPLACE_SHUFFLED
+    with nogil:
+        result = cufftXtMemcpy(plan, <void*>temp_arr, <void*>arr,
+                               CUFFT_COPY_DEVICE_TO_DEVICE)
+    check_result(result)
+
+    for i in range(nGPUs):
+        # swap MemoryPointer in xtArr_buffer
+        temp = temp_xtArr_buffer[i]
+        temp_xtArr_buffer[i] = xtArr_buffer[i]
+        xtArr_buffer[i] = temp
+
+        # swap pointer in xtArr
+        arr.descriptor.data[i] = temp_arr.descriptor.data[i]
+        assert arr.descriptor.size[i] == temp_arr.descriptor.size[i]
+        temp_arr.descriptor.data[i] = NULL
+        temp_arr.descriptor.size[i] = 0
+
+    # temp_xtArr now points to the old data, which is now in temp_xtArr_buffer
+    # and will be deallocated after this line (out of scope)
+    _XtFree(temp_xtArr)
+
+
+# This is meant to replace cufftXtMalloc().
+# We need to manage the buffers ourselves in order to 1. avoid excessive,
+# uncessary memory usage, and 2. use CuPy's memory pool.
+cdef _XtMalloc(list gpus, list sizes, XtSubFormat fmt):
+    cdef XtArrayDesc* xtArr_desc
+    cdef XtArray* xtArr
+    cdef list xtArr_buffer = []
+    cdef int i, nGPUs
+    cdef size_t size
+
+    nGPUs = len(gpus)
+    assert nGPUs == len(sizes)
+    xtArr_desc = <XtArrayDesc*>PyMem_Malloc(sizeof(XtArrayDesc))
+    xtArr = <XtArray*>PyMem_Malloc(sizeof(XtArray))
+    c_memset(xtArr_desc, 0, sizeof(XtArrayDesc))
+    c_memset(xtArr, 0, sizeof(XtArray))
+
+    xtArr_desc.nGPUs = nGPUs
+    for i, (gpu, size) in enumerate(zip(gpus, sizes)):
+        prev_device = runtime.getDevice()
+        runtime.setDevice(gpu)
+        try:
+            buf = memory.alloc(size)
+        finally:
+            runtime.setDevice(prev_device)
+        assert gpu == buf.device_id
+        xtArr_buffer.append(buf)
+        xtArr_desc.GPUs[i] = gpu
+        xtArr_desc.data[i] = <void*><intptr_t>(buf.ptr)
+        xtArr_desc.size[i] = size
+
+    xtArr.descriptor = xtArr_desc
+    xtArr.subFormat = fmt
+
+    return <intptr_t>xtArr, xtArr_buffer
+
+
+# This is meant to replace cufftXtFree().
+# We only free the C structs. The underlying GPU buffers are deallocated when
+# going out of scope.
+cdef _XtFree(intptr_t ptr):
+    cdef XtArray* xtArr = <XtArray*>ptr
+    cdef XtArrayDesc* xtArr_desc = xtArr.descriptor
+    PyMem_Free(xtArr_desc)
+    PyMem_Free(xtArr)
+
+
+cdef class Plan1d:
+    def __init__(self, int nx, int fft_type, int batch, *,
+                 devices=None, out=None):
+        cdef Handle plan
+        cdef bint use_multi_gpus = 0 if devices is None else 1
+        cdef int result
+
+        self.handle = <intptr_t>0
+        self.xtArr = <intptr_t>0  # pointer to metadata for multi-GPU buffer
+        self.xtArr_buffer = None  # actual multi-GPU intermediate buffer
+
+        with nogil:
+            result = cufftCreate(&plan)
+            if result == 0:
+                result = cufftSetAutoAllocation(plan, 0)
+        check_result(result)
+
+        self.handle = <intptr_t>plan
+        self.work_area = None
+        self.gpus = None
+
+        self.gather_streams = None
+        self.gather_events = None
+        self.scatter_streams = None
+        self.scatter_events = None
+
+        if batch != 0:
+            # set plan, work_area, gpus, streams, and events
+            if not use_multi_gpus:
+                self._single_gpu_get_plan(plan, nx, fft_type, batch)
+            else:
+                self._multi_gpu_get_plan(
+                    plan, nx, fft_type, batch, devices, out)
+        else:
+            if use_multi_gpus:
+                # multi-GPU FFT cannot transform 0-size arrays, and attempting
+                # to create such a plan will error out, but we still need this
+                # for bookkeeping
+                if isinstance(devices, (tuple, list)):
+                    self.gpus = list(devices)
+                elif isinstance(devices, int) and devices > 0:
+                    self.gpus = [i for i in range(int)]
+                else:
+                    raise ValueError
+
+        self.nx = nx
+        self.fft_type = <Type>fft_type
+        self.batch = batch
+        self.batch_share = None
+
+    cdef void _single_gpu_get_plan(self, Handle plan, int nx, int fft_type,
+                                   int batch) except*:
+        cdef int result
+        cdef size_t work_size
+        cdef intptr_t ptr
+
+        with nogil:
+            result = cufftMakePlan1d(plan, nx, <Type>fft_type, batch,
+                                     &work_size)
+
+        # cufftMakePlan1d uses large memory when nx has large divisor.
+        # See https://github.com/cupy/cupy/issues/1063
+        if result == 2:
+            cupy.get_default_memory_pool().free_all_blocks()
+            with nogil:
+                result = cufftMakePlan1d(plan, nx, <Type>fft_type, batch,
+                                         &work_size)
+        check_result(result)
+
+        work_area = memory.alloc(work_size)
+        ptr = <intptr_t>(work_area.ptr)
+        with nogil:
+            result = cufftSetWorkArea(plan, <void*>(ptr))
+        check_result(result)
+
+        self.work_area = work_area  # this is for cuFFT plan
+
+    cdef void _multi_gpu_get_plan(self, Handle plan, int nx, int fft_type,
+                                  int batch, devices, out) except*:
+        cdef int nGPUs, min_len, result
+        cdef vector.vector[int] gpus
+        cdef vector.vector[size_t] work_size
+        cdef list work_area = []
+        cdef list gather_streams = []
+        cdef list gather_events = []
+        cdef vector.vector[void*] work_area_ptr
+
+        # some sanity checks
+        if runtime.is_hip:
+            raise RuntimeError('hipFFT/rocFFT does not support multi-GPU FFT')
+        if fft_type != CUFFT_C2C and fft_type != CUFFT_Z2Z:
+            raise ValueError('Currently for multiple GPUs only C2C and Z2Z are'
+                             ' supported.')
+        if isinstance(devices, (tuple, list)):
+            nGPUs = len(devices)
+            for i in range(nGPUs):
+                gpus.push_back(devices[i])
+        elif isinstance(devices, int):
+            nGPUs = devices
+            for i in range(nGPUs):
+                gpus.push_back(i)
+        else:
+            raise ValueError('\"devices\" should be an int or an iterable '
+                             'of int.')
+        if batch == 1:
+            if (nx & (nx - 1)) != 0:
+                raise ValueError('For multi-GPU FFT with batch = 1, the array '
+                                 'size must be a power of 2.')
+            if nGPUs not in (2, 4, 8, 16):
+                raise ValueError('For multi-GPU FFT with batch = 1, the number'
+                                 ' of devices must be 2, 4, 8, or 16.')
+            if nGPUs in (2, 4):
+                min_len = 64
+            elif nGPUs == 8:
+                min_len = 128
+            else:  # nGPU = 16
+                min_len = 1024
+            if nx < min_len:
+                raise ValueError('For {} GPUs, the array length must be at '
+                                 'least {} (you have {}).'
+                                 .format(nGPUs, min_len, nx))
+        work_size.resize(nGPUs)
+
+        with nogil:
+            result = cufftXtSetGPUs(plan, nGPUs, gpus.data())
+            if result == 0:
+                result = cufftMakePlan1d(plan, nx, <Type>fft_type, batch,
+                                         work_size.data())
+
+        # cufftMakePlan1d uses large memory when nx has large divisor.
+        # See https://github.com/cupy/cupy/issues/1063
+        if result == 2:
+            cupy.get_default_memory_pool().free_all_blocks()
+            with nogil:
+                result = cufftMakePlan1d(plan, nx, <Type>fft_type, batch,
+                                         work_size.data())
+        check_result(result)
+
+        for i in range(nGPUs):
+            prev_device = runtime.getDevice()
+            runtime.setDevice(gpus[i])
+            try:
+                buf = memory.alloc(work_size[i])
+                s = stream.Stream()
+                e = stream.Event()
+            finally:
+                runtime.setDevice(prev_device)
+            work_area.append(buf)
+            work_area_ptr.push_back(<void*><intptr_t>(buf.ptr))
+            gather_streams.append(s)
+            gather_events.append(e)
+        with nogil:
+            result = cufftXtSetWorkArea(plan, work_area_ptr.data())
+        check_result(result)
+
+        self.work_area = work_area  # this is for cuFFT plan
+        self.gpus = list(gpus)
+
+        # For async, overlapped copies. We need to distinguish scatter and
+        # gather because for async memcpy, the stream is on the source device
+        self.gather_streams = gather_streams
+        self.gather_events = gather_events
+        self.scatter_streams = {}
+        self.scatter_events = {}
+        self._multi_gpu_get_scatter_streams_events(runtime.getDevice())
+
+    def _multi_gpu_get_scatter_streams_events(self, int curr_device):
+        '''
+        create a list of streams and events on the current device
+        '''
+        cdef int i
+        cdef list scatter_streams = []
+        cdef list scatter_events = []
+
+        assert curr_device in self.gpus
+        prev_device = runtime.getDevice()
+        runtime.setDevice(curr_device)
+        try:
+            for i in self.gpus:
+                scatter_streams.append(stream.Stream())
+                scatter_events.append(stream.Event())
+        finally:
+            runtime.setDevice(prev_device)
+        self.scatter_streams[curr_device] = scatter_streams
+        self.scatter_events[curr_device] = scatter_events
+
+    def __dealloc__(self):
+        cdef Handle plan = <Handle>self.handle
+        cdef int dev, result
+
+        if self.xtArr != 0:
+            _XtFree(self.xtArr)
+            self.xtArr = 0
+
+        try:
+            dev = runtime.getDevice()
+        except Exception as e:
+            # hack: the runtime module is purged at interpreter shutdown,
+            # since this is not a __del__ method, we can't use
+            # cupy._util.is_shutting_down()...
+            return
+
+        if plan != <Handle>0:
+            with nogil:
+                result = cufftDestroy(plan)
+            check_result(result)
+            self.handle = <intptr_t>0
+
+        # cuFFT bug: after cufftDestroy(), the current device is mistakenly
+        # set to the last device in self.gpus, so we must correct it. See
+        # https://github.com/cupy/cupy/pull/2644#discussion_r347567899 and
+        # NVIDIA internal ticket 2761341.
+        runtime.setDevice(dev)
+
+    def __enter__(self):
+        _thread_local._current_plan = self
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        _thread_local._current_plan = None
+
+    def fft(self, a, out, direction):
+        if self.gpus is not None:
+            self._multi_gpu_fft(a, out, direction)
+        else:
+            self._single_gpu_fft(a, out, direction)
+
+    def _single_gpu_fft(self, a, out, direction):
+        cdef intptr_t plan = self.handle
+        cdef intptr_t s = stream.get_current_stream().ptr
+        cdef int result
+
+        with nogil:
+            result = cufftSetStream(<Handle>plan, <Stream>s)
+        check_result(result)
+
+        if self.fft_type == CUFFT_C2C:
+            execC2C(plan, a.data.ptr, out.data.ptr, direction)
+        elif self.fft_type == CUFFT_R2C:
+            execR2C(plan, a.data.ptr, out.data.ptr)
+        elif self.fft_type == CUFFT_C2R:
+            execC2R(plan, a.data.ptr, out.data.ptr)
+        elif self.fft_type == CUFFT_Z2Z:
+            execZ2Z(plan, a.data.ptr, out.data.ptr, direction)
+        elif self.fft_type == CUFFT_D2Z:
+            execD2Z(plan, a.data.ptr, out.data.ptr)
+        elif self.fft_type == CUFFT_Z2D:
+            execZ2D(plan, a.data.ptr, out.data.ptr)
+        else:
+            raise ValueError
+
+    def _multi_gpu_setup_buffer(self, a):
+        cdef XtArrayDesc* xtArr_desc
+        cdef XtArray* xtArr
+        cdef intptr_t ptr
+        cdef list xtArr_buffer, share, sizes
+        cdef int i, nGPUs
+        cdef XtSubFormat fmt
+
+        # First, get the buffers:
+        # We need to manage the buffers ourselves in order to avoid excessive,
+        # uncessary memory usage. Note that these buffers are used for in-place
+        # transforms, and are re-used (lifetime tied to the plan).
+
+        if isinstance(a, cupy.ndarray) or isinstance(a, numpy.ndarray):
+            if self.xtArr == 0 and self.xtArr_buffer is None:
+                nGPUs = len(self.gpus)
+
+                # this is the rule for distributing the workload
+                if self.batch > 1:
+                    share = [self.batch // nGPUs] * nGPUs
+                    for i in range(self.batch % nGPUs):
+                        share[i] += 1
+                else:
+                    share = [1.0 / nGPUs] * nGPUs
+                sizes = [int(share[i] * self.nx * a.dtype.itemsize)
+                         for i in range(nGPUs)]
+
+                # get buffer
+                if isinstance(a, cupy.ndarray):
+                    fmt = CUFFT_XT_FORMAT_INPLACE
+                else:  # from numpy
+                    fmt = CUFFT_XT_FORMAT_1D_INPUT_SHUFFLED
+                ptr, xtArr_buffer = _XtMalloc(self.gpus, sizes, fmt)
+
+                xtArr = <XtArray*>ptr
+                xtArr_desc = xtArr.descriptor
+                assert xtArr_desc.nGPUs == nGPUs
+
+                self.batch_share = share
+                self.xtArr = ptr
+                self.xtArr_buffer = xtArr_buffer  # kept to ensure lifetime
+            else:
+                # After FFT the subFormat flag is silently changed to
+                # CUFFT_XT_FORMAT_INPLACE_SHUFFLED. For reuse we must correct
+                # it, otherwise in the next run we would encounter
+                # CUFFT_INVALID_TYPE!
+                ptr = self.xtArr
+                xtArr = <XtArray*>ptr
+                if self.batch == 1:
+                    if isinstance(a, cupy.ndarray):
+                        fmt = CUFFT_XT_FORMAT_INPLACE
+                    else:  # from numpy
+                        fmt = CUFFT_XT_FORMAT_1D_INPUT_SHUFFLED
+                    xtArr.subFormat = fmt
+        elif isinstance(a, list):
+            # TODO(leofang): For users running Plan1d.fft() (bypassing all
+            # checks in cupy.fft.fft), they are allowed to send in a list of
+            # ndarrays, each of which is on a different GPU. Then, no data
+            # copy is needed, just replace the pointers in the descriptor.
+            raise NotImplementedError('User-managed buffer area is not yet '
+                                      'supported.')
+        else:
+            raise ValueError('Impossible to reach.')
+
+    def _multi_gpu_memcpy(self, a, str action):
+        cdef Handle plan = <Handle>self.handle
+        cdef list xtArr_buffer, share
+        cdef int nGPUs, dev, s_device, start, count, result
+        cdef XtArray* arr
+        cdef intptr_t ptr, ptr2
+        cdef size_t size
+
+        assert isinstance(a, (cupy.ndarray, numpy.ndarray))
+
+        start = 0
+        assert a.flags.c_contiguous  # NumPy does not have _c_contiguous
+        b = a.ravel()
+        assert b.flags['OWNDATA'] is False
+        assert self.xtArr_buffer is not None
+        ptr = self.xtArr
+        arr = <XtArray*>ptr
+        xtArr_buffer = self.xtArr_buffer
+        nGPUs = len(self.gpus)
+        share = self.batch_share
+
+        if action == 'scatter':
+            if isinstance(a, cupy.ndarray):
+                s_device = b.data.device_id
+                if s_device not in self.scatter_streams:
+                    self._multi_gpu_get_scatter_streams_events(s_device)
+
+                # When we come here, another stream could still be
+                # copying data for us, so we wait patiently...
+                outer_stream = stream.get_current_stream()
+                outer_stream.synchronize()
+
+                for dev in range(nGPUs):
+                    count = int(share[dev] * self.nx)
+                    size = count * b.dtype.itemsize
+                    curr_stream = self.scatter_streams[s_device][dev]
+                    curr_event = self.scatter_events[s_device][dev]
+                    xtArr_buffer[dev].copy_from_device_async(
+                        b[start:start+count].data, size, curr_stream)
+                    if dev != 0:
+                        prev_event = self.scatter_events[s_device][dev-1]
+                        curr_stream.wait_event(prev_event)
+                    curr_event.record(curr_stream)
+                    start += count
+                assert start == b.size
+                self.scatter_events[s_device][-1].synchronize()
+            else:  # numpy
+                ptr2 = b.ctypes.data
+                with nogil:
+                    result = cufftXtMemcpy(
+                        plan, <void*>arr, <void*>ptr2,
+                        CUFFT_COPY_HOST_TO_DEVICE)
+                check_result(result)
+        elif action == 'gather':
+            if isinstance(a, cupy.ndarray):
+                if self.batch == 1:
+                    _reorder_buffers(plan, self.xtArr, xtArr_buffer)
+
+                # When we come here, another stream could still be
+                # copying data for us, so we wait patiently...
+                outer_stream = stream.get_current_stream()
+                outer_stream.synchronize()
+
+                for i in range(nGPUs):
+                    count = int(share[i] * self.nx)
+                    size = count * b.dtype.itemsize
+                    curr_stream = self.gather_streams[i]
+                    curr_event = self.gather_events[i]
+                    b[start:start+count].data.copy_from_device_async(
+                        xtArr_buffer[i], size, curr_stream)
+                    if i != 0:
+                        prev_event = self.gather_events[i-1]
+                        curr_stream.wait_event(prev_event)
+                    curr_event.record(curr_stream)
+                    start += count
+                assert start == b.size
+                self.gather_events[-1].synchronize()
+            else:  # numpy
+                ptr2 = b.ctypes.data
+                with nogil:
+                    result = cufftXtMemcpy(
+                        plan, <void*>ptr2, <void*>arr,
+                        CUFFT_COPY_DEVICE_TO_HOST)
+                check_result(result)
+        else:
+            raise ValueError
+
+    def _multi_gpu_fft(self, a, out, direction):
+        # When we arrive here, the normal CuPy call path ensures a and out
+        # reside on the same GPU -> must distribute a to all of the GPUs
+        self._multi_gpu_setup_buffer(a)
+
+        # Next, copy data to buffer
+        self._multi_gpu_memcpy(a, 'scatter')
+
+        # Actual workhorses
+        # Note: mult-GPU plans cannot set stream
+        cdef intptr_t plan = self.handle
+        if self.fft_type == CUFFT_C2C:
+            multi_gpu_execC2C(plan, self.xtArr, self.xtArr, direction)
+        elif self.fft_type == CUFFT_Z2Z:
+            multi_gpu_execZ2Z(plan, self.xtArr, self.xtArr, direction)
+        else:
+            raise ValueError
+
+        # Gather the distributed outputs
+        self._multi_gpu_memcpy(out, 'gather')
+
+    def _output_dtype_and_shape(self, a):
+        shape = list(a.shape)
+        if self.fft_type == CUFFT_C2C:
+            dtype = numpy.complex64
+        elif self.fft_type == CUFFT_R2C:
+            shape[-1] = shape[-1] // 2 + 1
+            dtype = numpy.complex64
+        elif self.fft_type == CUFFT_C2R:
+            shape[-1] = self.nx
+            dtype = numpy.float32
+        elif self.fft_type == CUFFT_Z2Z:
+            dtype = numpy.complex128
+        elif self.fft_type == CUFFT_D2Z:
+            shape[-1] = shape[-1] // 2 + 1
+            dtype = numpy.complex128
+        else:
+            shape[-1] = self.nx
+            dtype = numpy.float64
+        return tuple(shape), dtype
+
+    def get_output_array(self, a):
+        shape, dtype = self._output_dtype_and_shape(a)
+        return cupy.empty(shape, dtype)
+
+    def check_output_array(self, a, out):
+        """Verify shape and dtype of the output array.
+
+        Parameters
+        ----------
+        a : cupy.array
+            The input to the transform
+        out : cupy.array
+            The array where the output of the transform will be stored.
+        """
+        shape, dtype = self._output_dtype_and_shape(a)
+        if out.shape != shape:
+            raise ValueError(
+                ('out must have shape {}.').format(shape))
+        if out.dtype != dtype:
+            raise ValueError(
+                'out dtype mismatch: found {}, expected {}'.format(
+                    out.dtype, dtype))
+
+
+cdef class PlanNd:
+    def __init__(self, object shape, object inembed, int istride,
+                 int idist, object onembed, int ostride, int odist,
+                 int fft_type, int batch, str order, int last_axis, last_size):
+        cdef Handle plan
+        cdef size_t work_size
+        cdef int ndim, result
+        cdef vector.vector[int] shape_arr = shape
+        cdef vector.vector[int] inembed_arr
+        cdef vector.vector[int] onembed_arr
+        cdef int* shape_ptr = shape_arr.data()
+        cdef int* inembed_ptr
+        cdef int* onembed_ptr
+        cdef intptr_t ptr
+
+        self.handle = <intptr_t>0
+        ndim = len(shape)
+
+        if inembed is None:
+            inembed_ptr = NULL  # ignore istride and use default strides
+        else:
+            inembed_arr = inembed
+            inembed_ptr = inembed_arr.data()
+
+        if onembed is None:
+            onembed_ptr = NULL  # ignore ostride and use default strides
+        else:
+            onembed_arr = onembed
+            onembed_ptr = onembed_arr.data()
+
+        with nogil:
+            result = cufftCreate(&plan)
+            if result == 0:
+                result = cufftSetAutoAllocation(plan, 0)
+        check_result(result)
+
+        self.handle = <intptr_t>plan
+        self.gpus = None  # TODO(leofang): support multi-GPU PlanNd
+
+        if batch == 0:
+            work_size = 0
+        else:
+            with nogil:
+                result = cufftMakePlanMany(plan, ndim, shape_ptr,
+                                           inembed_ptr, istride, idist,
+                                           onembed_ptr, ostride, odist,
+                                           <Type>fft_type, batch,
+                                           &work_size)
+
+            # cufftMakePlanMany could use a large amount of memory
+            if result == 2:
+                cupy.get_default_memory_pool().free_all_blocks()
+                with nogil:
+                    result = cufftMakePlanMany(plan, ndim, shape_ptr,
+                                               inembed_ptr, istride, idist,
+                                               onembed_ptr, ostride, odist,
+                                               <Type>fft_type, batch,
+                                               &work_size)
+            check_result(result)
+
+        # TODO: for CUDA>=9.2 could also allow setting a work area policy
+        # result = cufftXtSetWorkAreaPolicy(plan, policy, &work_size)
+
+        work_area = memory.alloc(work_size)
+        ptr = <intptr_t>(work_area.ptr)
+        with nogil:
+            result = cufftSetWorkArea(plan, <void*>(ptr))
+        check_result(result)
+
+        self.shape = tuple(shape)
+        self.fft_type = <Type>fft_type
+        self.work_area = work_area
+        self.order = order  # either 'C' or 'F'
+        self.last_axis = last_axis  # ignored for C2C
+        self.last_size = last_size  # = None (and ignored) for C2C
+
+    def __dealloc__(self):
+        cdef Handle plan = <Handle>self.handle
+        cdef int result
+
+        if plan != <Handle>0:
+            with nogil:
+                result = cufftDestroy(plan)
+            check_result(result)
+            self.handle = <intptr_t>0
+
+    def __enter__(self):
+        _thread_local._current_plan = self
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        _thread_local._current_plan = None
+
+    def fft(self, a, out, direction):
+        cdef intptr_t plan = self.handle
+        cdef intptr_t s = stream.get_current_stream().ptr
+        cdef int result
+
+        with nogil:
+            result = cufftSetStream(<Handle>plan, <Stream>s)
+        check_result(result)
+
+        if self.fft_type == CUFFT_C2C:
+            execC2C(plan, a.data.ptr, out.data.ptr, direction)
+        elif self.fft_type == CUFFT_R2C:
+            execR2C(plan, a.data.ptr, out.data.ptr)
+        elif self.fft_type == CUFFT_C2R:
+            execC2R(plan, a.data.ptr, out.data.ptr)
+        elif self.fft_type == CUFFT_Z2Z:
+            execZ2Z(plan, a.data.ptr, out.data.ptr, direction)
+        elif self.fft_type == CUFFT_D2Z:
+            execD2Z(plan, a.data.ptr, out.data.ptr)
+        elif self.fft_type == CUFFT_Z2D:
+            execZ2D(plan, a.data.ptr, out.data.ptr)
+        else:
+            raise ValueError
+
+    def _output_dtype_and_shape(self, a):
+        shape = list(a.shape)
+        if self.fft_type == CUFFT_C2C:
+            dtype = numpy.complex64
+        elif self.fft_type == CUFFT_R2C:
+            shape[self.last_axis] = self.last_size
+            dtype = numpy.complex64
+        elif self.fft_type == CUFFT_C2R:
+            shape[self.last_axis] = self.last_size
+            dtype = numpy.float32
+        elif self.fft_type == CUFFT_Z2Z:
+            dtype = numpy.complex128
+        elif self.fft_type == CUFFT_D2Z:
+            shape[self.last_axis] = self.last_size
+            dtype = numpy.complex128
+        else:  # CUFFT_Z2D
+            shape[self.last_axis] = self.last_size
+            dtype = numpy.float64
+        return tuple(shape), dtype
+
+    def get_output_array(self, a, order='C'):
+        shape, dtype = self._output_dtype_and_shape(a)
+        return cupy.empty(shape, dtype, order=order)
+
+    def check_output_array(self, a, out):
+        if out is a:
+            # TODO(leofang): think about in-place transforms for C2R & R2C
+            return
+        if self.fft_type in (CUFFT_C2C, CUFFT_Z2Z):
+            if out.shape != a.shape:
+                raise ValueError('output shape mismatch')
+            if out.dtype != a.dtype:
+                raise ValueError('output dtype mismatch')
+        else:
+            if out.ndim != a.ndim:
+                raise ValueError('output dimension mismatch')
+            for i, size in enumerate(out.shape):
+                if (i != self.last_axis and size != a.shape[i]) or \
+                   (i == self.last_axis and size != self.last_size):
+                    raise ValueError('output shape is incorrecct')
+            if self.fft_type in (CUFFT_R2C, CUFFT_D2Z):
+                if out.dtype != cupy.dtype(a.dtype.char.upper()):
+                    raise ValueError('output dtype is unexpected')
+            else:  # CUFFT_C2R or CUFFT_Z2D
+                if out.dtype != cupy.dtype(a.dtype.char.lower()):
+                    raise ValueError('output dtype is unexpected')
+        if not ((out.flags.f_contiguous == a.flags.f_contiguous) and
+                (out.flags.c_contiguous == a.flags.c_contiguous)):
+            raise ValueError('output contiguity mismatch')
+
+
+# TODO(leofang): Unify with PlanND?!
+# TODO(leofang): support cufftXtSetGPUs?
+cdef class XtPlanNd:
+    def __init__(self, shape,
+                 inembed, long long int istride, long long int idist, idtype,
+                 onembed, long long int ostride, long long int odist, odtype,
+                 long long int batch, edtype, *,
+                 str order, int last_axis, last_size):
+        # Note: we don't pass in fft_type here because it's redundant and
+        # does not cover exotic types like complex32 or bf16
+
+        cdef Handle plan
+        cdef size_t work_size
+        cdef int ndim, result
+        cdef vector.vector[long long int] shape_arr = shape
+        cdef vector.vector[long long int] inembed_arr
+        cdef vector.vector[long long int] onembed_arr
+        cdef long long int* shape_ptr = shape_arr.data()
+        cdef long long int* inembed_ptr
+        cdef long long int* onembed_ptr
+
+        self.handle = <intptr_t>0
+        ndim = len(shape)
+
+        if inembed is None:
+            inembed_ptr = NULL  # ignore istride and use default strides
+        else:
+            inembed_arr = inembed
+            inembed_ptr = inembed_arr.data()
+
+        if onembed is None:
+            onembed_ptr = NULL  # ignore ostride and use default strides
+        else:
+            onembed_arr = onembed
+            onembed_ptr = onembed_arr.data()
+
+        with nogil:
+            result = cufftCreate(&plan)
+            if result == 0:
+                result = cufftSetAutoAllocation(plan, 0)
+        check_result(result)
+
+        self.handle = <intptr_t>plan
+        self.gpus = None  # TODO(leofang): support multi-GPU plans
+
+        # determine input/output/execution types here; note that we don't
+        # cimport to_cuda_dtype due to circular dependency
+        from cupy._core._dtype import to_cuda_dtype
+        cdef int itype = to_cuda_dtype(idtype, True)
+        cdef int otype = to_cuda_dtype(odtype, True)
+        cdef int etype = to_cuda_dtype(edtype, True)
+
+        cdef long long int length
+        cdef long long int full = 1
+        for length in shape:
+            full *= length
+        length = last_size if last_size is not None else shape[-1]
+        try:
+            self._sanity_checks(itype, otype, etype, length, full)
+        except AssertionError:
+            raise ValueError('input/output/execution types mismatch')
+
+        if batch == 0:
+            work_size = 0
+        else:
+            with nogil:
+                result = cufftXtMakePlanMany(
+                    plan, ndim, shape_ptr,
+                    inembed_ptr, istride, idist, <DataType>itype,
+                    onembed_ptr, ostride, odist, <DataType>otype,
+                    batch, &work_size, <DataType>etype)
+
+            # cufftMakePlanMany could use a large amount of memory
+            if result == 2:
+                cupy.get_default_memory_pool().free_all_blocks()
+                with nogil:
+                    result = cufftXtMakePlanMany(
+                        plan, ndim, shape_ptr,
+                        inembed_ptr, istride, idist, <DataType>itype,
+                        onembed_ptr, ostride, odist, <DataType>otype,
+                        batch, &work_size, <DataType>etype)
+            check_result(result)
+
+        work_area = memory.alloc(work_size)
+        cdef intptr_t ptr = <intptr_t>(work_area.ptr)
+        with nogil:
+            result = cufftSetWorkArea(plan, <void*>(ptr))
+        check_result(result)
+
+        self.shape = tuple(shape)
+        self.itype = itype
+        self.otype = otype
+        self.etype = etype
+        self.work_area = work_area
+        self.order = order  # either 'C' or 'F'
+        self.last_axis = last_axis  # ignored for C2C
+        self.last_size = last_size  # = None (and ignored) for C2C
+
+    def __dealloc__(self):
+        cdef Handle plan = <Handle>self.handle
+        cdef int result
+
+        if plan != <Handle>0:
+            with nogil:
+                result = cufftDestroy(plan)
+            check_result(result)
+            self.handle = <intptr_t>0
+
+    def __enter__(self):
+        _thread_local._current_plan = self
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        _thread_local._current_plan = None
+
+    def fft(self, a, out, direction):
+        cdef intptr_t plan = self.handle
+        cdef intptr_t s = stream.get_current_stream().ptr
+        cdef int result
+
+        with nogil:
+            result = cufftSetStream(<Handle>plan, <Stream>s)
+        check_result(result)
+        XtExec(plan, a.data.ptr, out.data.ptr, direction)
+
+    def _sanity_checks(self, int itype, int otype, int etype,
+                       long long int last_size, long long int full_size):
+        # not every possible type combination is legit
+        # TODO(leofang): support bf16?
+        # C2C
+        if itype == runtime.CUDA_C_16F and otype == runtime.CUDA_C_16F:
+            assert etype == runtime.CUDA_C_16F
+        elif itype == runtime.CUDA_C_32F and otype == runtime.CUDA_C_32F:
+            assert etype == runtime.CUDA_C_32F
+        elif itype == runtime.CUDA_C_64F and otype == runtime.CUDA_C_64F:
+            assert etype == runtime.CUDA_C_64F
+        # C2R
+        elif itype == runtime.CUDA_C_16F and otype == runtime.CUDA_R_16F:
+            assert etype == runtime.CUDA_C_16F
+        elif itype == runtime.CUDA_C_32F and otype == runtime.CUDA_R_32F:
+            assert etype == runtime.CUDA_C_32F
+        elif itype == runtime.CUDA_C_64F and otype == runtime.CUDA_R_64F:
+            assert etype == runtime.CUDA_C_64F
+        # R2C
+        elif itype == runtime.CUDA_R_16F and otype == runtime.CUDA_C_16F:
+            assert etype == runtime.CUDA_C_16F
+        elif itype == runtime.CUDA_R_32F and otype == runtime.CUDA_C_32F:
+            assert etype == runtime.CUDA_C_32F
+        elif itype == runtime.CUDA_R_64F and otype == runtime.CUDA_C_64F:
+            assert etype == runtime.CUDA_C_64F
+        else:
+            assert False
+
+        # check fp16 runtime constraints
+        # https://docs.nvidia.com/cuda/cufft/index.html#half-precision-transforms
+        if etype == runtime.CUDA_C_16F:
+            if int(device.get_compute_capability()) < 53:
+                raise RuntimeError("this device doesn't support complex32 FFT")
+            if (last_size & (last_size - 1)) != 0:
+                raise ValueError('size must be power of 2')
+            if full_size > 4000000000:
+                raise ValueError('input array too large')
+            # TODO(leofang): check if multi-GPU is requested
+        # TODO(leofang): also check for bf16?
+        # https://docs.nvidia.com/cuda/cufft/index.html#bfloat16-precision-transforms
+
+    def _output_dtype_and_shape(self, a):
+        shape = list(a.shape)
+        if self.itype != self.otype:  # R2C or C2R
+            shape[self.last_axis] = self.last_size
+        if self.otype == runtime.CUDA_C_16F:
+            # dtype = numpy.complex32
+            raise NotImplementedError('complex32 is not supported yet, please '
+                                      'allocate the output array manually')
+        elif self.otype == runtime.CUDA_C_32F:
+            dtype = numpy.complex64
+        elif self.otype == runtime.CUDA_C_64F:
+            dtype = numpy.complex128
+        elif self.otype == runtime.CUDA_R_16F:
+            dtype = numpy.float16
+        elif self.otype == runtime.CUDA_R_32F:
+            dtype = numpy.float32
+        elif self.otype == runtime.CUDA_R_64F:
+            dtype = numpy.float64
+        return tuple(shape), dtype
+
+    def get_output_array(self, a, order='C'):
+        shape, dtype = self._output_dtype_and_shape(a)
+        return cupy.empty(shape, dtype, order=order)
+
+
+cpdef execC2C(intptr_t plan, intptr_t idata, intptr_t odata, int direction):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftExecC2C(h, <Complex*>idata, <Complex*>odata,
+                              direction)
+    check_result(result)
+
+
+cpdef execR2C(intptr_t plan, intptr_t idata, intptr_t odata):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftExecR2C(h, <Float*>idata, <Complex*>odata)
+    check_result(result)
+
+
+cpdef execC2R(intptr_t plan, intptr_t idata, intptr_t odata):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftExecC2R(h, <Complex*>idata, <Float*>odata)
+    check_result(result)
+
+
+cpdef execZ2Z(intptr_t plan, intptr_t idata, intptr_t odata, int direction):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftExecZ2Z(h, <DoubleComplex*>idata,
+                              <DoubleComplex*>odata, direction)
+    check_result(result)
+
+
+cpdef execD2Z(intptr_t plan, intptr_t idata, intptr_t odata):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftExecD2Z(h, <Double*>idata, <DoubleComplex*>odata)
+    check_result(result)
+
+
+cpdef execZ2D(intptr_t plan, intptr_t idata, intptr_t odata):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftExecZ2D(h, <DoubleComplex*>idata, <Double*>odata)
+    check_result(result)
+
+
+cpdef multi_gpu_execC2C(intptr_t plan, intptr_t idata, intptr_t odata,
+                        int direction):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftXtExecDescriptorC2C(h, <XtArray*>idata,
+                                          <XtArray*>odata, direction)
+    check_result(result)
+
+
+cpdef multi_gpu_execZ2Z(intptr_t plan, intptr_t idata, intptr_t odata,
+                        int direction):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftXtExecDescriptorZ2Z(h, <XtArray*>idata,
+                                          <XtArray*>odata, direction)
+    check_result(result)
+
+
+cpdef XtExec(intptr_t plan, intptr_t idata, intptr_t odata, int direction):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftXtExec(h, <void*>idata, <void*>odata, direction)
+    check_result(result)
+
+
+cpdef intptr_t setCallback(
+        intptr_t plan, int cb_type, bint is_load, intptr_t aux_arr=0):
+    cdef Handle h = <Handle>plan  # no-cython-lint
+    cdef int result  # no-cython-lint
+    cdef void** callerInfo  # no-cython-lint
+
+    IF CUPY_CUFFT_STATIC:
+        with nogil:
+            if aux_arr > 0:
+                callerInfo = (<void**>(&aux_arr))
+            else:
+                callerInfo = NULL
+            result = set_callback(
+                h, <callbackType>cb_type, is_load, callerInfo)
+        check_result(result)
+    ELSE:
+        raise RuntimeError('cuFFT is dynamically linked and thus does not '
+                           'support callback')

vllm/lib/python3.10/site-packages/cupy/cuda/cupy_cub.cu

@@ -0,0 +1,1189 @@
+#include "cupy_cub.h"  // need to make atomicAdd visible to CUB templates early
+#include <cupy/type_dispatcher.cuh>
+
+#ifndef CUPY_USE_HIP
+#include <cfloat> // For FLT_MAX definitions
+#include <cub/device/device_reduce.cuh>
+#include <cub/device/device_segmented_reduce.cuh>
+#include <cub/device/device_spmv.cuh>
+#include <cub/device/device_scan.cuh>
+#include <cub/device/device_histogram.cuh>
+#include <cub/iterator/counting_input_iterator.cuh>
+#include <cub/iterator/transform_input_iterator.cuh>
+#include <cuda/functional>
+#include <cuda/std/functional>
+#else
+#include <hipcub/device/device_reduce.hpp>
+#include <hipcub/device/device_segmented_reduce.hpp>
+#include <hipcub/device/device_scan.hpp>
+#include <hipcub/device/device_histogram.hpp>
+#include <rocprim/iterator/counting_iterator.hpp>
+#include <hipcub/iterator/transform_input_iterator.hpp>
+#endif
+
+
+/* ------------------------------------ Minimum boilerplate to support complex numbers ------------------------------------ */
+#ifndef CUPY_USE_HIP
+// - This works only because all data fields in the *Traits struct are not
+//   used in <cub/device/device_reduce.cuh>.
+// - The Max() and Lowest() below are chosen to comply with NumPy's lexical
+//   ordering; note that std::numeric_limits<T> does not support complex
+//   numbers as in general the comparison is ill defined.
+// - DO NOT USE THIS STUB for supporting CUB sorting!!!!!!
+using namespace cub;
+#define CUPY_CUB_NAMESPACE cub
+
+template <>
+struct FpLimits<complex<float>>
+{
+    static __host__ __device__ __forceinline__ complex<float> Max() {
+        return (complex<float>(FLT_MAX, FLT_MAX));
+    }
+
+    static __host__ __device__ __forceinline__ complex<float> Lowest() {
+        return (complex<float>(FLT_MAX * float(-1), FLT_MAX * float(-1)));
+    }
+};
+
+template <>
+struct FpLimits<complex<double>>
+{
+    static __host__ __device__ __forceinline__ complex<double> Max() {
+        return (complex<double>(DBL_MAX, DBL_MAX));
+    }
+
+    static __host__ __device__ __forceinline__ complex<double> Lowest() {
+        return (complex<double>(DBL_MAX * double(-1), DBL_MAX * double(-1)));
+    }
+};
+
+template <> struct NumericTraits<complex<float>>  : BaseTraits<FLOATING_POINT, true, false, unsigned int, complex<float>> {};
+template <> struct NumericTraits<complex<double>> : BaseTraits<FLOATING_POINT, true, false, unsigned long long, complex<double>> {};
+
+// need specializations for initial values
+namespace std {
+
+template <>
+class numeric_limits<thrust::complex<float>> {
+  public:
+    static __host__ __device__ thrust::complex<float> infinity() noexcept {
+        return thrust::complex<float>(std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity());
+    }
+
+    static constexpr bool has_infinity = true;
+};
+
+template <>
+class numeric_limits<thrust::complex<double>> {
+  public:
+    static __host__ __device__ thrust::complex<double> infinity() noexcept {
+        return thrust::complex<double>(std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity());
+    }
+
+    static constexpr bool has_infinity = true;
+};
+
+template <>
+class numeric_limits<__half> {
+  public:
+    static __host__ __device__ constexpr __half infinity() noexcept {
+        unsigned short inf_half = 0x7C00U;
+        #if (defined(_MSC_VER) && _MSC_VER >= 1920)
+        #if CUDA_VERSION < 11030
+        // WAR: CUDA 11.2.x + VS 2019 fails with __builtin_bit_cast
+        union caster {
+            unsigned short u_;
+            __half h_;
+        };
+        return caster{inf_half}.h_;
+        #else  // CUDA_VERSION < 11030
+        // WAR:
+        // - we want a constexpr here, but reinterpret_cast cannot be used
+        // - we want to use std::bit_cast, but it requires C++20 which is too new
+        // - we use the compiler builtin, fortunately both gcc and msvc have it
+        return __builtin_bit_cast(__half, inf_half);
+        #endif
+        #else
+        return *reinterpret_cast<__half*>(&inf_half);
+        #endif
+    }
+
+    static constexpr bool has_infinity = true;
+};
+
+}  // namespace std
+
+
+#else
+
+// hipCUB internally uses std::numeric_limits, so we should provide specializations for the complex numbers.
+// Note that there's std::complex, so to avoid name collision we must use the full decoration (thrust::complex)!
+// TODO(leofang): wrap CuPy's thrust namespace with another one (say, cupy::thrust) for safer scope resolution?
+#define CUPY_CUB_NAMESPACE hipcub
+
+namespace std {
+template <>
+class numeric_limits<thrust::complex<float>> {
+  public:
+    static __host__ __device__ thrust::complex<float> max() noexcept {
+        return thrust::complex<float>(std::numeric_limits<float>::max(), std::numeric_limits<float>::max());
+    }
+
+    static __host__ __device__ thrust::complex<float> lowest() noexcept {
+        return thrust::complex<float>(-std::numeric_limits<float>::max(), -std::numeric_limits<float>::max());
+    }
+
+    static __host__ __device__ thrust::complex<float> infinity() noexcept {
+        return thrust::complex<float>(std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity());
+    }
+
+    static constexpr bool has_infinity = true;
+};
+
+template <>
+class numeric_limits<thrust::complex<double>> {
+  public:
+    static __host__ __device__ thrust::complex<double> max() noexcept {
+        return thrust::complex<double>(std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
+    }
+
+    static __host__ __device__ thrust::complex<double> lowest() noexcept {
+        return thrust::complex<double>(-std::numeric_limits<double>::max(), -std::numeric_limits<double>::max());
+    }
+
+    static __host__ __device__ thrust::complex<double> infinity() noexcept {
+        return thrust::complex<double>(std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity());
+    }
+
+    static constexpr bool has_infinity = true;
+};
+
+// Copied from https://github.com/ROCmSoftwarePlatform/hipCUB/blob/master-rocm-3.5/hipcub/include/hipcub/backend/rocprim/device/device_reduce.hpp
+// (For some reason the specialization for __half defined in the above file does not work, so we have to go
+// through the same route as we did above for complex numbers.)
+template <>
+class numeric_limits<__half> {
+  public:
+    static __host__ __device__ __half max() noexcept {
+        unsigned short max_half = 0x7bff;
+        __half max_value = *reinterpret_cast<__half*>(&max_half);
+        return max_value;
+    }
+
+    static __host__ __device__ __half lowest() noexcept {
+        unsigned short lowest_half = 0xfbff;
+        __half lowest_value = *reinterpret_cast<__half*>(&lowest_half);
+        return lowest_value;
+    }
+
+    static __host__ __device__ __half infinity() noexcept {
+        unsigned short inf_half = 0x7C00U;
+        __half inf_value = *reinterpret_cast<__half*>(&inf_half);
+        return inf_value;
+    }
+
+    static constexpr bool has_infinity = true;
+};
+}  // namespace std
+
+using namespace hipcub;
+
+#endif  // ifndef CUPY_USE_HIP
+
+__host__ __device__ __half half_negate_inf() {
+    unsigned short minf_half = 0xFC00U;
+    __half* minf_value = reinterpret_cast<__half*>(&minf_half);
+    return *minf_value;
+}
+
+/* ------------------------------------ end of boilerplate ------------------------------------ */
+
+
+/* ------------------------------------ "Patches" to CUB ------------------------------------
+   This stub is needed because CUB does not have a built-in "prod" operator
+*/
+
+//
+// product functor
+//
+#ifdef CUPY_USE_HIP
+struct _multiply
+{
+    template <typename T>
+    __host__ __device__ __forceinline__ T operator()(const T &a, const T &b) const
+    {
+        return a * b;
+    }
+};
+#else
+using _multiply = cuda::std::multiplies<>;
+#endif
+
+//
+// arange functor: arange(0, n+1) -> arange(0, n+1, step_size)
+//
+struct _arange
+{
+    private:
+        int step_size;
+
+    public:
+    __host__ __device__ __forceinline__ _arange(int i): step_size(i) {}
+    __host__ __device__ __forceinline__ int operator()(const int &in) const {
+        return step_size * in;
+    }
+};
+
+#ifndef CUPY_USE_HIP
+typedef TransformInputIterator<int, _arange, CountingInputIterator<int>> seg_offset_itr;
+#else
+typedef TransformInputIterator<int, _arange, rocprim::counting_iterator<int>> seg_offset_itr;
+#endif
+
+/*
+   These stubs are needed because CUB does not handle NaNs properly, while NumPy has certain
+   behaviors with which we must comply.
+
+   CUDA/HIP have different signatures for Max/Min because of the recent changes in CCCL (for the former).
+*/
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+    && (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+__host__ __device__ __forceinline__ bool half_isnan(const __half& x) {
+#if defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__)
+    return __hisnan(x);
+#else
+    // TODO: avoid cast to float
+    return isnan(__half2float(x));
+#endif
+}
+
+__host__ __device__ __forceinline__ bool half_less(const __half& l, const __half& r) {
+#if defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__)
+    return l < r;
+#else
+    // TODO: avoid cast to float
+    return __half2float(l) < __half2float(r);
+#endif
+}
+
+__host__ __device__ __forceinline__ bool half_equal(const __half& l, const __half& r) {
+#if defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__)
+    return l == r;
+#else
+    // TODO: avoid cast to float
+    return __half2float(l) == __half2float(r);
+#endif
+}
+#endif
+
+#ifdef CUPY_USE_HIP
+
+//
+// Max()
+//
+
+template <typename T>
+struct select_max {
+    using type = Max;
+};
+
+// specialization for float for handling NaNs
+template <>
+__host__ __device__ __forceinline__ float Max::operator()(const float &a, const float &b) const
+{
+    // NumPy behavior: NaN is always chosen!
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? b : a;}
+}
+
+// specialization for double for handling NaNs
+template <>
+__host__ __device__ __forceinline__ double Max::operator()(const double &a, const double &b) const
+{
+    // NumPy behavior: NaN is always chosen!
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? b : a;}
+}
+
+// specialization for complex<float> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ complex<float> Max::operator()(const complex<float> &a, const complex<float> &b) const
+{
+    // - TODO(leofang): just call max() here when the bug in cupy/complex.cuh is fixed
+    // - NumPy behavior: If both a and b contain NaN, the first argument is chosen
+    // - isnan() and max() are defined in cupy/complex.cuh
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? b : a;}
+}
+
+// specialization for complex<double> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ complex<double> Max::operator()(const complex<double> &a, const complex<double> &b) const
+{
+    // - TODO(leofang): just call max() here when the bug in cupy/complex.cuh is fixed
+    // - NumPy behavior: If both a and b contain NaN, the first argument is chosen
+    // - isnan() and max() are defined in cupy/complex.cuh
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? b : a;}
+}
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+    && (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+// specialization for half for handling NaNs
+template <>
+__host__ __device__ __forceinline__ __half Max::operator()(const __half &a, const __half &b) const
+{
+    // NumPy behavior: NaN is always chosen!
+    if (half_isnan(a)) {return a;}
+    else if (half_isnan(b)) {return b;}
+    else { return half_less(a, b) ? b : a; }
+}
+#endif
+
+//
+// Min()
+//
+
+template <typename T>
+struct select_min {
+    using type = Min;
+};
+
+// specialization for float for handling NaNs
+template <>
+__host__ __device__ __forceinline__ float Min::operator()(const float &a, const float &b) const
+{
+    // NumPy behavior: NaN is always chosen!
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? a : b;}
+}
+
+// specialization for double for handling NaNs
+template <>
+__host__ __device__ __forceinline__ double Min::operator()(const double &a, const double &b) const
+{
+    // NumPy behavior: NaN is always chosen!
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? a : b;}
+}
+
+// specialization for complex<float> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ complex<float> Min::operator()(const complex<float> &a, const complex<float> &b) const
+{
+    // - TODO(leofang): just call min() here when the bug in cupy/complex.cuh is fixed
+    // - NumPy behavior: If both a and b contain NaN, the first argument is chosen
+    // - isnan() and min() are defined in cupy/complex.cuh
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? a : b;}
+}
+
+// specialization for complex<double> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ complex<double> Min::operator()(const complex<double> &a, const complex<double> &b) const
+{
+    // - TODO(leofang): just call min() here when the bug in cupy/complex.cuh is fixed
+    // - NumPy behavior: If both a and b contain NaN, the first argument is chosen
+    // - isnan() and min() are defined in cupy/complex.cuh
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? a : b;}
+}
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+    && (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+// specialization for half for handling NaNs
+template <>
+__host__ __device__ __forceinline__ __half Min::operator()(const __half &a, const __half &b) const
+{
+    // NumPy behavior: NaN is always chosen!
+    if (half_isnan(a)) {return a;}
+    else if (half_isnan(b)) {return b;}
+    else { return half_less(a, b) ? a : b; }
+}
+#endif
+
+#endif  // ifdef CUPY_USE_HIP
+
+//
+// ArgMax()
+//
+
+// specialization for float for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, float> ArgMax::operator()(
+    const KeyValuePair<int, float> &a,
+    const KeyValuePair<int, float> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value > a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+// specialization for double for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, double> ArgMax::operator()(
+    const KeyValuePair<int, double> &a,
+    const KeyValuePair<int, double> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value > a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+// specialization for complex<float> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, complex<float>> ArgMax::operator()(
+    const KeyValuePair<int, complex<float>> &a,
+    const KeyValuePair<int, complex<float>> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value > a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+// specialization for complex<double> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, complex<double>> ArgMax::operator()(
+    const KeyValuePair<int, complex<double>> &a,
+    const KeyValuePair<int, complex<double>> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value > a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+    && (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+// specialization for half for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, __half> ArgMax::operator()(
+    const KeyValuePair<int, __half> &a,
+    const KeyValuePair<int, __half> &b) const
+{
+    if (half_isnan(a.value))
+        return a;
+    else if (half_isnan(b.value))
+        return b;
+    else if ((half_less(a.value, b.value)) ||
+             (half_equal(a.value, b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+#endif
+
+//
+// ArgMin()
+//
+
+// specialization for float for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, float> ArgMin::operator()(
+    const KeyValuePair<int, float> &a,
+    const KeyValuePair<int, float> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value < a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+// specialization for double for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, double> ArgMin::operator()(
+    const KeyValuePair<int, double> &a,
+    const KeyValuePair<int, double> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value < a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+// specialization for complex<float> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, complex<float>> ArgMin::operator()(
+    const KeyValuePair<int, complex<float>> &a,
+    const KeyValuePair<int, complex<float>> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value < a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+// specialization for complex<double> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, complex<double>> ArgMin::operator()(
+    const KeyValuePair<int, complex<double>> &a,
+    const KeyValuePair<int, complex<double>> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value < a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+    && (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+// specialization for half for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, __half> ArgMin::operator()(
+    const KeyValuePair<int, __half> &a,
+    const KeyValuePair<int, __half> &b) const
+{
+    if (half_isnan(a.value))
+        return a;
+    else if (half_isnan(b.value))
+        return b;
+    else if ((half_less(b.value, a.value)) ||
+             (half_equal(a.value, b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+
+}
+#endif
+
+#ifndef CUPY_USE_HIP
+
+//
+// Max()
+//
+
+template <typename T>
+struct select_max {
+#if CCCL_VERSION >= 2008000
+    using type = cuda::maximum<>;
+#else
+    using type = cub::Max;
+#endif
+};
+
+template <typename T>
+struct nan_handling_max {
+    __host__ __device__ __forceinline__ T operator()(const T &a, const T &b) const {
+        // NumPy behavior: NaN is always chosen!
+        if (isnan(a)) {return a;}
+        else if (isnan(b)) {return b;}
+        else {return a < b ? b : a;}
+    }
+};
+
+template <>
+struct select_max<float> {
+    using type = nan_handling_max<float>;
+};
+
+template <>
+struct select_max<double> {
+    using type = nan_handling_max<double>;
+};
+
+// - NumPy behavior: If both a and b contain NaN, the first argument is chosen
+// - isnan() and max() are defined in cupy/complex.cuh
+template <>
+struct select_max<complex<float>> {
+    using type = nan_handling_max<complex<float>>;
+};
+template <>
+struct select_max<complex<double>> {
+    using type = nan_handling_max<complex<double>>;
+};
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+&& (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+template <>
+struct select_max<__half> {
+    struct type {
+        __host__ __device__ __forceinline__ __half operator()(const __half &a, const __half &b) const {
+            // NumPy behavior: NaN is always chosen!
+            if (half_isnan(a)) {return a;}
+            else if (half_isnan(b)) {return b;}
+            else { return half_less(a, b) ? b : a; }
+        }
+    };
+};
+#endif
+
+//
+// Min()
+//
+template <typename T>
+struct select_min {
+#if CCCL_VERSION >= 2008000
+    using type = cuda::minimum<>;
+#else
+    using type = cub::Min;
+#endif
+};
+
+template <typename T>
+struct nan_handling_min {
+    __host__ __device__ __forceinline__ T operator()(const T &a, const T &b) const {
+        // NumPy behavior: NaN is always chosen!
+        if (isnan(a)) {return a;}
+        else if (isnan(b)) {return b;}
+        else {return a < b ? a : b;}
+    }
+};
+
+template <>
+struct select_min<float> {
+    using type = nan_handling_min<float>;
+};
+
+template <>
+struct select_min<double> {
+    using type = nan_handling_min<double>;
+};
+
+// - NumPy behavior: If both a and b contain NaN, the first argument is chosen
+// - isnan() and min() are defined in cupy/complex.cuh
+template <>
+struct select_min<complex<float>> {
+    using type = nan_handling_min<complex<float>>;
+};
+template <>
+struct select_min<complex<double>> {
+    using type = nan_handling_min<complex<double>>;
+};
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+&& (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+template <>
+struct select_min<__half> {
+    struct type {
+        __host__ __device__ __forceinline__ __half operator()(const __half &a, const __half &b) const {
+            // NumPy behavior: NaN is always chosen!
+            if (half_isnan(a)) {return a;}
+            else if (half_isnan(b)) {return b;}
+            else { return half_less(a, b) ? a: b; }
+        }
+    };
+};
+#endif
+
+#endif  // #ifndef CUPY_USE_HIP
+
+/* ------------------------------------ End of "patches" ------------------------------------ */
+
+//
+// **** CUB Sum ****
+//
+struct _cub_reduce_sum {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_items, cudaStream_t s)
+    {
+        DeviceReduce::Sum(workspace, workspace_size, static_cast<T*>(x),
+            static_cast<T*>(y), num_items, s);
+    }
+};
+
+struct _cub_segmented_reduce_sum {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_segments, seg_offset_itr offset_start, cudaStream_t s)
+    {
+        DeviceSegmentedReduce::Sum(workspace, workspace_size,
+            static_cast<T*>(x), static_cast<T*>(y), num_segments,
+            offset_start, offset_start+1, s);
+    }
+};
+
+//
+// **** CUB Prod ****
+//
+struct _cub_reduce_prod {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_items, cudaStream_t s)
+    {
+        _multiply product_op;
+        // the init value is cast from 1.0f because on host __half can only be
+        // initialized by float or double; static_cast<__half>(1) = 0 on host.
+        DeviceReduce::Reduce(workspace, workspace_size, static_cast<T*>(x),
+            static_cast<T*>(y), num_items, product_op, static_cast<T>(1.0f), s);
+    }
+};
+
+struct _cub_segmented_reduce_prod {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_segments, seg_offset_itr offset_start, cudaStream_t s)
+    {
+        _multiply product_op;
+        // the init value is cast from 1.0f because on host __half can only be
+        // initialized by float or double; static_cast<__half>(1) = 0 on host.
+        DeviceSegmentedReduce::Reduce(workspace, workspace_size,
+            static_cast<T*>(x), static_cast<T*>(y), num_segments,
+            offset_start, offset_start+1,
+            product_op, static_cast<T>(1.0f), s);
+    }
+};
+
+//
+// **** CUB Min ****
+//
+struct _cub_reduce_min {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_items, cudaStream_t s)
+    {
+        if constexpr (std::numeric_limits<T>::has_infinity)
+        {
+            DeviceReduce::Reduce(workspace, workspace_size, static_cast<T*>(x),
+                static_cast<T*>(y), num_items,
+                typename select_min<T>::type{}, std::numeric_limits<T>::infinity(), s);
+        }
+        else
+        {
+            DeviceReduce::Min(workspace, workspace_size, static_cast<T*>(x),
+                static_cast<T*>(y), num_items, s);
+        }
+    }
+};
+
+struct _cub_segmented_reduce_min {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_segments, seg_offset_itr offset_start, cudaStream_t s)
+    {
+        if constexpr (std::numeric_limits<T>::has_infinity)
+        {
+            DeviceSegmentedReduce::Reduce(workspace, workspace_size,
+                static_cast<T*>(x), static_cast<T*>(y), num_segments,
+                offset_start, offset_start+1,
+                typename select_min<T>::type{}, std::numeric_limits<T>::infinity(), s);
+        }
+        else
+        {
+            DeviceSegmentedReduce::Min(workspace, workspace_size,
+                static_cast<T*>(x), static_cast<T*>(y), num_segments,
+                offset_start, offset_start+1, s);
+        }
+    }
+};
+
+//
+// **** CUB Max ****
+//
+struct _cub_reduce_max {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_items, cudaStream_t s)
+    {
+        if constexpr (std::numeric_limits<T>::has_infinity)
+        {
+            // to avoid compiler error: invalid argument type '__half' to unary expression on HIP...
+            if constexpr (std::is_same_v<T, __half>)
+            {
+                DeviceReduce::Reduce(workspace, workspace_size, static_cast<T*>(x),
+                    static_cast<T*>(y), num_items,
+                    typename select_max<T>::type{}, half_negate_inf(), s);
+            }
+            else
+            {
+                DeviceReduce::Reduce(workspace, workspace_size, static_cast<T*>(x),
+                    static_cast<T*>(y), num_items,
+                    typename select_max<T>::type{}, -std::numeric_limits<T>::infinity(), s);
+
+            }
+        }
+        else
+        {
+            DeviceReduce::Max(workspace, workspace_size, static_cast<T*>(x),
+                static_cast<T*>(y), num_items, s);
+        }
+    }
+};
+
+struct _cub_segmented_reduce_max {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_segments, seg_offset_itr offset_start, cudaStream_t s)
+    {
+        if constexpr (std::numeric_limits<T>::has_infinity)
+        {
+            // to avoid compiler error: invalid argument type '__half' to unary expression on HIP...
+            if constexpr (std::is_same_v<T, __half>)
+            {
+                DeviceSegmentedReduce::Reduce(workspace, workspace_size,
+                    static_cast<T*>(x), static_cast<T*>(y), num_segments,
+                    offset_start, offset_start+1,
+                    typename select_max<T>::type{}, half_negate_inf(), s);
+            }
+            else
+            {
+                DeviceSegmentedReduce::Reduce(workspace, workspace_size,
+                    static_cast<T*>(x), static_cast<T*>(y), num_segments,
+                    offset_start, offset_start+1,
+                    typename select_max<T>::type{}, -std::numeric_limits<T>::infinity(), s);
+            }
+        }
+        else
+        {
+            DeviceSegmentedReduce::Max(workspace, workspace_size,
+                static_cast<T*>(x), static_cast<T*>(y), num_segments,
+                offset_start, offset_start+1, s);
+        }
+    }
+};
+
+//
+// **** CUB ArgMin ****
+//
+struct _cub_reduce_argmin {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_items, cudaStream_t s)
+    {
+        DeviceReduce::ArgMin(workspace, workspace_size, static_cast<T*>(x),
+            static_cast<KeyValuePair<int, T>*>(y), num_items, s);
+    }
+};
+
+// TODO(leofang): add _cub_segmented_reduce_argmin
+
+//
+// **** CUB ArgMax ****
+//
+struct _cub_reduce_argmax {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_items, cudaStream_t s)
+    {
+        DeviceReduce::ArgMax(workspace, workspace_size, static_cast<T*>(x),
+            static_cast<KeyValuePair<int, T>*>(y), num_items, s);
+    }
+};
+
+// TODO(leofang): add _cub_segmented_reduce_argmax
+
+//
+// **** CUB SpMV ****
+//
+struct _cub_device_spmv {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* values,
+        void* row_offsets, void* column_indices, void* x, void* y,
+        int num_rows, int num_cols, int num_nonzeros, cudaStream_t stream)
+    {
+        #ifndef CUPY_USE_HIP
+        DeviceSpmv::CsrMV(workspace, workspace_size, static_cast<T*>(values),
+            static_cast<int*>(row_offsets), static_cast<int*>(column_indices),
+            static_cast<T*>(x), static_cast<T*>(y), num_rows, num_cols,
+            num_nonzeros, stream);
+        #endif
+    }
+};
+
+//
+// **** CUB InclusiveSum  ****
+//
+struct _cub_inclusive_sum {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* input, void* output,
+        int num_items, cudaStream_t s)
+    {
+        DeviceScan::InclusiveSum(workspace, workspace_size, static_cast<T*>(input),
+            static_cast<T*>(output), num_items, s);
+    }
+};
+
+//
+// **** CUB inclusive product  ****
+//
+struct _cub_inclusive_product {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* input, void* output,
+        int num_items, cudaStream_t s)
+    {
+        _multiply product_op;
+        DeviceScan::InclusiveScan(workspace, workspace_size, static_cast<T*>(input),
+            static_cast<T*>(output), product_op, num_items, s);
+    }
+};
+
+//
+// **** CUB histogram range ****
+//
+struct _cub_histogram_range {
+    template <typename sampleT,
+              typename binT = typename std::conditional<std::is_integral<sampleT>::value, double, sampleT>::type>
+    void operator()(void* workspace, size_t& workspace_size, void* input, void* output,
+        int n_bins, void* bins, size_t n_samples, cudaStream_t s) const
+    {
+        // Ugly hack to avoid specializing complex types, which cub::DeviceHistogram does not support.
+        // TODO(leofang): revisit this part when complex support is added to cupy.histogram()
+        typedef typename std::conditional<(std::is_same<sampleT, complex<float>>::value || std::is_same<sampleT, complex<double>>::value),
+                                          double,
+                                          sampleT>::type h_sampleT;
+        typedef typename std::conditional<(std::is_same<binT, complex<float>>::value || std::is_same<binT, complex<double>>::value),
+                                          double,
+                                          binT>::type h_binT;
+
+        // TODO(leofang): CUB has a bug that when specializing n_samples with type size_t,
+        // it would error out. Before the fix (thrust/cub#38) is merged we disable the code
+        // path splitting for now. A type/range check must be done in the caller.
+        // TODO(leofang): check if hipCUB has the same bug or not
+
+        // if (n_samples < (1ULL << 31)) {
+            int num_samples = n_samples;
+            DeviceHistogram::HistogramRange(workspace, workspace_size, static_cast<h_sampleT*>(input),
+                #ifndef CUPY_USE_HIP
+                static_cast<long long*>(output), n_bins, static_cast<h_binT*>(bins), num_samples, s);
+                #else
+                // rocPRIM looks up atomic_add() from the namespace rocprim::detail; there's no way we can
+                // inject a "long long" version as we did for CUDA, so we must do it in "unsigned long long"
+                // and convert later...
+                static_cast<unsigned long long*>(output), n_bins, static_cast<h_binT*>(bins), num_samples, s);
+                #endif
+        // } else {
+        //     DeviceHistogram::HistogramRange(workspace, workspace_size, static_cast<h_sampleT*>(input),
+        //         static_cast<long long*>(output), n_bins, static_cast<h_binT*>(bins), n_samples, s);
+        // }
+    }
+};
+
+//
+// **** CUB histogram even ****
+//
+struct _cub_histogram_even {
+    template <typename sampleT>
+    void operator()(void* workspace, size_t& workspace_size, void* input, void* output,
+        int& n_bins, int& lower, int& upper, size_t n_samples, cudaStream_t s) const
+    {
+        #ifndef CUPY_USE_HIP
+        // Ugly hack to avoid specializing numerical types
+        typedef typename std::conditional<std::is_integral<sampleT>::value, sampleT, int>::type h_sampleT;
+        int num_samples = n_samples;
+        static_assert(sizeof(long long) == sizeof(intptr_t), "not supported");
+        DeviceHistogram::HistogramEven(workspace, workspace_size, static_cast<h_sampleT*>(input),
+            static_cast<long long*>(output), n_bins, lower, upper, num_samples, s);
+        #else
+        throw std::runtime_error("HIP is not supported yet");
+        #endif
+    }
+};
+
+//
+// APIs exposed to CuPy
+//
+
+/* -------- device reduce -------- */
+
+void cub_device_reduce(void* workspace, size_t& workspace_size, void* x, void* y,
+    int num_items, cudaStream_t stream, int op, int dtype_id)
+{
+    switch(op) {
+    case CUPY_CUB_SUM:      return dtype_dispatcher(dtype_id, _cub_reduce_sum(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    case CUPY_CUB_MIN:      return dtype_dispatcher(dtype_id, _cub_reduce_min(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    case CUPY_CUB_MAX:      return dtype_dispatcher(dtype_id, _cub_reduce_max(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    case CUPY_CUB_ARGMIN:   return dtype_dispatcher(dtype_id, _cub_reduce_argmin(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    case CUPY_CUB_ARGMAX:   return dtype_dispatcher(dtype_id, _cub_reduce_argmax(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    case CUPY_CUB_PROD:     return dtype_dispatcher(dtype_id, _cub_reduce_prod(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    default:            throw std::runtime_error("Unsupported operation");
+    }
+}
+
+size_t cub_device_reduce_get_workspace_size(void* x, void* y, int num_items,
+    cudaStream_t stream, int op, int dtype_id)
+{
+    size_t workspace_size = 0;
+    cub_device_reduce(NULL, workspace_size, x, y, num_items, stream,
+                      op, dtype_id);
+    return workspace_size;
+}
+
+/* -------- device segmented reduce -------- */
+
+void cub_device_segmented_reduce(void* workspace, size_t& workspace_size,
+    void* x, void* y, int num_segments, int segment_size,
+    cudaStream_t stream, int op, int dtype_id)
+{
+    // CUB internally use int for offset...
+    // This iterates over [0, segment_size, 2*segment_size, 3*segment_size, ...]
+    #ifndef CUPY_USE_HIP
+    CountingInputIterator<int> count_itr(0);
+    #else
+    rocprim::counting_iterator<int> count_itr(0);
+    #endif
+    _arange scaling(segment_size);
+    seg_offset_itr itr(count_itr, scaling);
+
+    switch(op) {
+    case CUPY_CUB_SUM:
+        return dtype_dispatcher(dtype_id, _cub_segmented_reduce_sum(),
+                   workspace, workspace_size, x, y, num_segments, itr, stream);
+    case CUPY_CUB_MIN:
+        return dtype_dispatcher(dtype_id, _cub_segmented_reduce_min(),
+                   workspace, workspace_size, x, y, num_segments, itr, stream);
+    case CUPY_CUB_MAX:
+        return dtype_dispatcher(dtype_id, _cub_segmented_reduce_max(),
+                   workspace, workspace_size, x, y, num_segments, itr, stream);
+    case CUPY_CUB_PROD:
+        return dtype_dispatcher(dtype_id, _cub_segmented_reduce_prod(),
+                   workspace, workspace_size, x, y, num_segments, itr, stream);
+    default:
+        throw std::runtime_error("Unsupported operation");
+    }
+}
+
+size_t cub_device_segmented_reduce_get_workspace_size(void* x, void* y,
+    int num_segments, int segment_size,
+    cudaStream_t stream, int op, int dtype_id)
+{
+    size_t workspace_size = 0;
+    cub_device_segmented_reduce(NULL, workspace_size, x, y,
+                                num_segments, segment_size, stream,
+                                op, dtype_id);
+    return workspace_size;
+}
+
+/*--------- device spmv (sparse-matrix dense-vector multiply) ---------*/
+
+void cub_device_spmv(void* workspace, size_t& workspace_size, void* values,
+    void* row_offsets, void* column_indices, void* x, void* y, int num_rows,
+    int num_cols, int num_nonzeros, cudaStream_t stream,
+    int dtype_id)
+{
+    #ifndef CUPY_USE_HIP
+    return dtype_dispatcher(dtype_id, _cub_device_spmv(),
+                            workspace, workspace_size, values, row_offsets,
+                            column_indices, x, y, num_rows, num_cols,
+                            num_nonzeros, stream);
+    #endif
+}
+
+size_t cub_device_spmv_get_workspace_size(void* values, void* row_offsets,
+    void* column_indices, void* x, void* y, int num_rows, int num_cols,
+    int num_nonzeros, cudaStream_t stream, int dtype_id)
+{
+    size_t workspace_size = 0;
+    #ifndef CUPY_USE_HIP
+    cub_device_spmv(NULL, workspace_size, values, row_offsets, column_indices,
+                    x, y, num_rows, num_cols, num_nonzeros, stream, dtype_id);
+    #endif
+    return workspace_size;
+}
+
+/* -------- device scan -------- */
+
+void cub_device_scan(void* workspace, size_t& workspace_size, void* x, void* y,
+    int num_items, cudaStream_t stream, int op, int dtype_id)
+{
+    switch(op) {
+    case CUPY_CUB_CUMSUM:
+        return dtype_dispatcher(dtype_id, _cub_inclusive_sum(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    case CUPY_CUB_CUMPROD:
+        return dtype_dispatcher(dtype_id, _cub_inclusive_product(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    default:
+        throw std::runtime_error("Unsupported operation");
+    }
+}
+
+size_t cub_device_scan_get_workspace_size(void* x, void* y, int num_items,
+    cudaStream_t stream, int op, int dtype_id)
+{
+    size_t workspace_size = 0;
+    cub_device_scan(NULL, workspace_size, x, y, num_items, stream,
+                    op, dtype_id);
+    return workspace_size;
+}
+
+/* -------- device histogram -------- */
+
+void cub_device_histogram_range(void* workspace, size_t& workspace_size, void* x, void* y,
+    int n_bins, void* bins, size_t n_samples, cudaStream_t stream, int dtype_id)
+{
+    // TODO(leofang): support complex
+    if (dtype_id == CUPY_TYPE_COMPLEX64 || dtype_id == CUPY_TYPE_COMPLEX128) {
+	    throw std::runtime_error("complex dtype is not yet supported");
+    }
+
+    // TODO(leofang): n_samples is of type size_t, but if it's < 2^31 we cast it to int later
+    return dtype_dispatcher(dtype_id, _cub_histogram_range(),
+                            workspace, workspace_size, x, y, n_bins, bins, n_samples, stream);
+}
+
+size_t cub_device_histogram_range_get_workspace_size(void* x, void* y, int n_bins,
+    void* bins, size_t n_samples, cudaStream_t stream, int dtype_id)
+{
+    size_t workspace_size = 0;
+    cub_device_histogram_range(NULL, workspace_size, x, y, n_bins, bins, n_samples,
+                               stream, dtype_id);
+    return workspace_size;
+}
+
+void cub_device_histogram_even(void* workspace, size_t& workspace_size, void* x, void* y,
+    int n_bins, int lower, int upper, size_t n_samples, cudaStream_t stream, int dtype_id)
+{
+    #ifndef CUPY_USE_HIP
+    return dtype_dispatcher(dtype_id, _cub_histogram_even(),
+                            workspace, workspace_size, x, y, n_bins, lower, upper, n_samples, stream);
+    #endif
+}
+
+size_t cub_device_histogram_even_get_workspace_size(void* x, void* y, int n_bins,
+    int lower, int upper, size_t n_samples, cudaStream_t stream, int dtype_id)
+{
+    size_t workspace_size = 0;
+    cub_device_histogram_even(NULL, workspace_size, x, y, n_bins, lower, upper, n_samples,
+                              stream, dtype_id);
+    return workspace_size;
+}

vllm/lib/python3.10/site-packages/cupy/cuda/cupy_cufft.h

@@ -0,0 +1,324 @@
+#ifndef INCLUDE_GUARD_CUPY_CUFFT_H
+#define INCLUDE_GUARD_CUPY_CUFFT_H
+
+/*
+ * Note: this file should *not* be split into 3 and moved under cupy_backends/,
+ * because we need to copy this header to sdist and use it at runtime for cuFFT
+ * callbacks.
+ */
+
+#if !defined(CUPY_NO_CUDA) && !defined(CUPY_USE_HIP)
+#include <cufft.h>
+#include <cufftXt.h>
+
+#elif defined(CUPY_USE_HIP)
+#include <hipfft.h>
+
+extern "C" {
+
+typedef hipfftComplex cufftComplex;
+typedef hipfftDoubleComplex cufftDoubleComplex;
+typedef hipfftReal cufftReal;
+typedef hipfftDoubleReal cufftDoubleReal;
+
+typedef hipfftResult_t cufftResult_t;
+typedef hipfftHandle cufftHandle;
+typedef hipfftType_t cufftType_t;
+typedef hipStream_t cudaStream_t;
+
+// cuFFT Helper Function
+cufftResult_t cufftCreate(cufftHandle* plan) {
+    return hipfftCreate(plan);
+}
+
+cufftResult_t cufftDestroy(cufftHandle plan) {
+    return hipfftDestroy(plan);
+}
+
+cufftResult_t cufftSetAutoAllocation(cufftHandle plan, int autoAllocate) {
+    return hipfftSetAutoAllocation(plan, autoAllocate);
+}
+
+cufftResult_t cufftSetWorkArea(cufftHandle plan, void *workArea) {
+    return hipfftSetWorkArea(plan, workArea);
+}
+
+// cuFFT Stream Function
+cufftResult_t cufftSetStream(cufftHandle plan, cudaStream_t stream) {
+    return hipfftSetStream(plan, stream);
+}
+
+// cuFFT Plan Functions
+cufftResult_t cufftMakePlan1d(cufftHandle plan,
+                              int nx,
+                              cufftType_t type,
+                              int batch,
+                              size_t *workSize) {
+    return hipfftMakePlan1d(plan, nx, type, batch, workSize);
+}
+
+cufftResult_t cufftMakePlanMany(cufftHandle plan,
+                                int rank,
+                                int *n,
+                                int *inembed, int istride, int idist,
+                                int *onembed, int ostride, int odist,
+                                cufftType_t type,
+                                int batch,
+                                size_t *workSize) {
+    return hipfftMakePlanMany(plan, rank, n,
+                              inembed, istride, idist,
+                              onembed, ostride, odist,
+                              type, batch, workSize);
+}
+
+// cuFFT Exec Function
+cufftResult_t cufftExecC2C(cufftHandle plan,
+                           cufftComplex *idata,
+                           cufftComplex *odata,
+                           int direction) {
+    return hipfftExecC2C(plan, idata, odata, direction);
+}
+
+cufftResult_t cufftExecR2C(cufftHandle plan,
+                           cufftReal *idata,
+                           cufftComplex *odata) {
+    return hipfftExecR2C(plan, idata, odata);
+}
+
+cufftResult_t cufftExecC2R(cufftHandle plan,
+                           cufftComplex *idata,
+                           cufftReal *odata) {
+    return hipfftExecC2R(plan, idata, odata);
+}
+
+cufftResult_t cufftExecZ2Z(cufftHandle plan,
+                           cufftDoubleComplex *idata,
+                           cufftDoubleComplex *odata,
+                           int direction) {
+    return hipfftExecZ2Z(plan, idata, odata, direction);
+}
+
+cufftResult_t cufftExecD2Z(cufftHandle plan,
+                           cufftDoubleReal *idata,
+                           cufftDoubleComplex *odata) {
+    return hipfftExecD2Z(plan, idata, odata);
+}
+
+cufftResult_t cufftExecZ2D(cufftHandle plan,
+                           cufftDoubleComplex *idata,
+                           cufftDoubleReal *odata) {
+    return hipfftExecZ2D(plan, idata, odata);
+}
+
+// cuFFT Version
+cufftResult_t cufftGetVersion(int *version) {
+    return hipfftGetVersion(version);
+}
+
+// TODO(leofang): move this header to cupy_backends/ and include hip/cupy_hip_common.h
+typedef enum {} cudaDataType;
+
+// cufftXt functions
+cufftResult_t cufftXtSetGPUs(...) {
+    return HIPFFT_NOT_IMPLEMENTED;
+}
+
+cufftResult_t cufftXtSetWorkArea(...) {
+    return HIPFFT_NOT_IMPLEMENTED;
+}
+
+cufftResult_t cufftXtMemcpy(...) {
+    return HIPFFT_NOT_IMPLEMENTED;
+}
+
+cufftResult_t cufftXtMakePlanMany(...) {
+    return HIPFFT_NOT_IMPLEMENTED;
+}
+
+cufftResult_t cufftXtExec(...) {
+    return HIPFFT_NOT_IMPLEMENTED;
+}
+
+cufftResult_t cufftXtExecDescriptorC2C(...) {
+    return HIPFFT_NOT_IMPLEMENTED;
+}
+
+cufftResult_t cufftXtExecDescriptorZ2Z(...) {
+    return HIPFFT_NOT_IMPLEMENTED;
+}
+
+} // extern "C"
+
+#else  // defined(CUPY_NO_CUDA)
+
+#include "../../cupy_backends/stub/cupy_cuda_common.h"
+#include "../../cupy_backends/stub/cupy_cuComplex.h"
+
+extern "C" {
+
+typedef float cufftReal;
+typedef double cufftDoubleReal;
+typedef cuComplex cufftComplex;
+typedef cuDoubleComplex cufftDoubleComplex;
+
+typedef enum {
+    CUFFT_SUCCESS = 0,
+    CUFFT_INVALID_PLAN = 1,
+    CUFFT_ALLOC_FAILED = 2,
+    CUFFT_INVALID_TYPE = 3,
+    CUFFT_INVALID_VALUE = 4,
+    CUFFT_INTERNAL_ERROR = 5,
+    CUFFT_EXEC_FAILED = 6,
+    CUFFT_SETUP_FAILED = 7,
+    CUFFT_INVALID_SIZE = 8,
+    CUFFT_UNALIGNED_DATA = 9,
+    CUFFT_INCOMPLETE_PARAMETER_LIST = 10,
+    CUFFT_INVALID_DEVICE = 11,
+    CUFFT_PARSE_ERROR = 12,
+    CUFFT_NO_WORKSPACE = 13,
+    CUFFT_NOT_IMPLEMENTED = 14,
+    CUFFT_LICENSE_ERROR = 15,
+    CUFFT_NOT_SUPPORTED = 16,
+} cufftResult_t;
+
+typedef int cufftHandle;
+
+typedef enum {} cufftType_t;
+
+// cuFFT Helper Function
+cufftResult_t cufftCreate(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftDestroy(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftSetAutoAllocation(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftSetWorkArea(...) {
+    return CUFFT_SUCCESS;
+}
+
+// cuFFT Stream Function
+cufftResult_t cufftSetStream(...) {
+    return CUFFT_SUCCESS;
+}
+
+// cuFFT Plan Functions
+cufftResult_t cufftMakePlan1d(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftMakePlanMany(...) {
+    return CUFFT_SUCCESS;
+}
+
+// cuFFT Exec Function
+cufftResult_t cufftExecC2C(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftExecR2C(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftExecC2R(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftExecZ2Z(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftExecD2Z(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftExecZ2D(...) {
+    return CUFFT_SUCCESS;
+}
+
+// cuFFT Version
+cufftResult_t cufftGetVersion(...) {
+    return CUFFT_SUCCESS;
+}
+
+// cufftXt functions
+cufftResult_t cufftXtSetGPUs(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftXtSetWorkArea(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftXtMemcpy(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftXtMakePlanMany(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftXtExec(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftXtExecDescriptorC2C(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftXtExecDescriptorZ2Z(...) {
+    return CUFFT_SUCCESS;
+}
+
+}  // extern "C"
+
+#endif  // #if !defined(CUPY_NO_CUDA) && !defined(CUPY_USE_HIP)
+
+#if defined(CUPY_NO_CUDA) || defined(CUPY_USE_HIP)
+// common stubs for both no-cuda and hip environments
+
+extern "C" {
+// cufftXt relevant data structs
+typedef struct cudaXtDesc_t {
+   int version;
+   int nGPUs;
+   int GPUs[64];
+   void* data[64];
+   size_t size[64];
+   void* cudaXtState;
+} cudaXtDesc;
+
+typedef enum cufftXtSubFormat_t {
+    CUFFT_XT_FORMAT_INPUT = 0x00,
+    CUFFT_XT_FORMAT_OUTPUT = 0x01,
+    CUFFT_XT_FORMAT_INPLACE = 0x02,
+    CUFFT_XT_FORMAT_INPLACE_SHUFFLED = 0x03,
+    CUFFT_XT_FORMAT_1D_INPUT_SHUFFLED = 0x04,
+    CUFFT_FORMAT_UNDEFINED = 0x05
+} cufftXtSubFormat;
+
+typedef struct cudaLibXtDesc_t{
+    int version;
+    cudaXtDesc *descriptor;
+    int library;  // libFormat is an undoumented type, so use int here
+    int subFormat;
+    void *libDescriptor;
+} cudaLibXtDesc;
+
+typedef enum cufftXtCopyType_t {
+    CUFFT_COPY_HOST_TO_DEVICE = 0x00,
+    CUFFT_COPY_DEVICE_TO_HOST = 0x01,
+    CUFFT_COPY_DEVICE_TO_DEVICE = 0x02,
+    CUFFT_COPY_UNDEFINED = 0x03
+} cufftXtCopyType;
+
+} // extern "C"
+
+#endif // #if defined(CUPY_NO_CUDA) || defined(CUPY_USE_HIP)
+
+#endif  // INCLUDE_GUARD_CUPY_CUFFT_H

vllm/lib/python3.10/site-packages/cupy/cuda/cupy_cufftXt.cu

@@ -0,0 +1,68 @@
+#include "cupy_cufftXt.h"
+
+
+// this must define d_loadCallbackPtr
+${dev_load_callback_ker}
+
+// this must define d_storeCallbackPtr
+${dev_store_callback_ker}
+
+cufftResult set_callback(cufftHandle plan, cufftXtCallbackType type, bool cb_load, void** callerInfo) {
+    if (cb_load) {
+        switch (type) {
+            #ifdef HAS_LOAD_CALLBACK
+            case CUFFT_CB_LD_COMPLEX: {
+                cufftCallbackLoadC h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_loadCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            case CUFFT_CB_LD_COMPLEX_DOUBLE: {
+                cufftCallbackLoadZ h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_loadCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            case CUFFT_CB_LD_REAL: {
+                cufftCallbackLoadR h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_loadCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            case CUFFT_CB_LD_REAL_DOUBLE: {
+                cufftCallbackLoadD h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_loadCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            #endif  // HAS_LOAD_CALLBACK
+            default: {
+                throw std::runtime_error("unrecognized callback");
+            }
+        }
+    } else {
+        switch (type) {
+            #ifdef HAS_STORE_CALLBACK
+            case CUFFT_CB_ST_COMPLEX: {
+                cufftCallbackStoreC h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_storeCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            case CUFFT_CB_ST_COMPLEX_DOUBLE: {
+                cufftCallbackStoreZ h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_storeCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            case CUFFT_CB_ST_REAL: {
+                cufftCallbackStoreR h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_storeCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            case CUFFT_CB_ST_REAL_DOUBLE: {
+                cufftCallbackStoreD h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_storeCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            #endif  // HAS_STORE_CALLBACK
+            default: {
+                throw std::runtime_error("unrecognized callback");
+            }
+        }
+    }
+}

vllm/lib/python3.10/site-packages/cupy/cuda/cupy_cufftXt.h

@@ -0,0 +1,10 @@
+#include <cufftXt.h>
+#include <cstdint>
+#include <stdexcept>
+
+
+extern "C" {
+
+cufftResult set_callback(cufftHandle plan, cufftXtCallbackType cbType, bool cb_load, void** callerInfo=NULL);
+
+}

vllm/lib/python3.10/site-packages/cupy/cuda/cupy_thrust.cu

@@ -0,0 +1,526 @@
+#include "cupy_thrust.h"
+#include <cupy/type_dispatcher.cuh>
+#include <thrust/device_ptr.h>
+#include <thrust/device_vector.h>
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/iterator/constant_iterator.h>
+#include <thrust/sequence.h>
+#include <thrust/sort.h>
+#include <thrust/tuple.h>
+#include <thrust/execution_policy.h>
+#include <type_traits>
+#if (__CUDACC_VER_MAJOR__ >11 || (__CUDACC_VER_MAJOR__ == 11 && __CUDACC_VER_MINOR__ >= 2) || HIP_VERSION >= 402)
+// This is used to avoid a problem with constexpr in functions declarations introduced in
+// cuda 11.2, MSVC 15 does not fully support it so we need a dummy constexpr declaration
+// that is provided by this header. However optional.h is only available
+// starting CUDA 10.1
+#include <thrust/optional.h>
+
+#ifdef _MSC_VER
+#define THRUST_OPTIONAL_CPP11_CONSTEXPR_LESS constexpr
+#else
+#define THRUST_OPTIONAL_CPP11_CONSTEXPR_LESS THRUST_OPTIONAL_CPP11_CONSTEXPR
+#endif
+
+#endif
+
+
+#if CUPY_USE_HIP
+typedef hipStream_t cudaStream_t;
+namespace cuda {
+    using thrust::hip::par;
+}
+#else // #if CUPY_USE_HIP
+namespace cuda {
+    using thrust::cuda::par;
+}
+#endif // #if CUPY_USE_HIP
+
+
+extern "C" char *cupy_malloc(void *, size_t);
+extern "C" int cupy_free(void *, char *);
+
+
+class cupy_allocator {
+private:
+    void* memory;
+
+public:
+    typedef char value_type;
+
+    cupy_allocator(void* memory) : memory(memory) {}
+
+    char *allocate(size_t num_bytes) {
+        return cupy_malloc(memory, num_bytes);
+    }
+
+    void deallocate(char *ptr, size_t n) {
+        cupy_free(memory, ptr);
+    }
+};
+
+
+/*
+ * ------------------------------------- Minimum boilerplate for NumPy compatibility --------------------------------------
+ * We need a specialized operator< here in order to match the NumPy behavior:
+ * "The sort order for complex numbers is lexicographic. If both the real and imaginary parts are non-nan then the order is
+ * determined by the real parts except when they are equal, in which case the order is determined by the imaginary parts.
+ *
+ * In numpy versions >= 1.4.0 nan values are sorted to the end. The extended sort order is:
+ *     Real: [R, nan]
+ *     Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj]
+ * where R is a non-nan real value. Complex values with the same nan placements are sorted according to the non-nan part if
+ * it exists. Non-nan values are sorted as before."
+ * Ref: https://numpy.org/doc/stable/reference/generated/numpy.sort.html
+ */
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+&& (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+    #define ENABLE_HALF
+#endif
+
+#if (__CUDACC_VER_MAJOR__ >11 || (__CUDACC_VER_MAJOR__ == 11 && __CUDACC_VER_MINOR__ >= 2))
+    #define CONSTEXPR_FUNC THRUST_OPTIONAL_CPP11_CONSTEXPR
+#else
+    #define CONSTEXPR_FUNC
+#endif
+
+#if (__CUDACC_VER_MAJOR__ >11 || (__CUDACC_VER_MAJOR__ == 11 && __CUDACC_VER_MINOR__ >= 2) || HIP_VERSION >= 402)
+    #define CONSTEXPR_COMPARATOR THRUST_OPTIONAL_CPP11_CONSTEXPR_LESS
+#else
+    #define CONSTEXPR_COMPARATOR
+#endif
+
+#ifdef ENABLE_HALF
+__host__ __device__ __forceinline__ bool isnan(const __half& x) {
+    #if (defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__))
+    return __hisnan(x);
+    #else
+    return false;  // This will never be called on the host
+    #endif
+}
+#endif // ENABLE_HALF
+
+template <typename T>
+__host__ __device__ __forceinline__ CONSTEXPR_FUNC
+static bool real_less(const T& lhs, const T& rhs) {
+#if  (defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__))
+    if (isnan(lhs)) {
+        return false;
+    } else if (isnan(rhs)) {
+        return true;
+    } else {
+        return lhs < rhs;
+    }
+#else
+    return false;  // This will be never executed in the host
+#endif
+}
+
+template <typename T>
+__host__ __device__ __forceinline__ CONSTEXPR_FUNC
+static bool tuple_less(const thrust::tuple<size_t, T>& lhs,
+		 const thrust::tuple<size_t, T>& rhs) {
+    const size_t& lhs_k = thrust::get<0>(lhs);
+    const size_t& rhs_k = thrust::get<0>(rhs);
+    const T& lhs_v = thrust::get<1>(lhs);
+    const T& rhs_v = thrust::get<1>(rhs);
+
+    // tuple's comparison rule: compare the 1st member, then 2nd, then 3rd, ...,
+    // which should be respected
+    if (lhs_k < rhs_k) {
+        return true;
+    } else if (lhs_k == rhs_k) {
+        // same key, compare values
+        // note that we can't rely on native operator< due to NaN, so we rely on our custom comparison object
+        return real_less(lhs_v, rhs_v);
+    } else {
+        return false;
+    }
+}
+
+/*
+ * ********** complex numbers **********
+ * We need a custom comparator because we can't overload operator< for complex numbers...
+ */
+
+template <typename T>
+__host__ __device__ __forceinline__ CONSTEXPR_FUNC
+static bool complex_less(const T& lhs, const T& rhs) {
+    const bool lhsRe = isnan(lhs.real());
+    const bool lhsIm = isnan(lhs.imag());
+    const bool rhsRe = isnan(rhs.real());
+    const bool rhsIm = isnan(rhs.imag());
+
+    // neither side has nan
+    if (!lhsRe && !lhsIm && !rhsRe && !rhsIm) {
+        return lhs < rhs;
+    }
+
+    // one side has nan, and the other does not
+    if (!lhsRe && !lhsIm && (rhsRe || rhsIm)) {
+        return true;
+    }
+    if ((lhsRe || lhsIm) && !rhsRe && !rhsIm) {
+        return false;
+    }
+
+    // pick 2 from 3 possibilities (R + nanj, nan + Rj, nan + nanj)
+    if (lhsRe && !rhsRe) {
+        return false;
+    }
+    if (!lhsRe && rhsRe) {
+        return true;
+    }
+    if (lhsIm && !rhsIm) {
+        return false;
+    }
+    if (!lhsIm && rhsIm) {
+        return true;
+    }
+
+    // pick 1 from 3 and compare the numerical values (nan+nan*I compares to itself as false)
+    return (((lhsIm && rhsIm) && (lhs.real() < rhs.real())) || ((lhsRe && rhsRe) && (lhs.imag() < rhs.imag())));
+}
+
+// Type function giving us the right comparison operator. We use a custom one for all the specializations below,
+// but otherwise just default to thrust::less. We notable do not define a specialization for float and double, since
+// thrust uses radix sort for them and sorts NaNs to the back.
+template <typename T>
+struct select_less {
+    using type = thrust::less<T>;
+};
+
+// complex numbers
+
+template <>
+struct select_less<complex<float>> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (
+            const complex<float>& lhs, const complex<float>& rhs) const {
+            return complex_less(lhs, rhs);
+        }
+    };
+};
+
+template <>
+struct select_less<complex<double>> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (
+            const complex<double>& lhs, const complex<double>& rhs) const {
+            return complex_less(lhs, rhs);
+        }
+    };
+};
+
+template <>
+struct select_less<thrust::tuple<size_t, complex<float>>> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (
+            const thrust::tuple<size_t, complex<float>>& lhs, const thrust::tuple<size_t, complex<float>>& rhs) const {
+            return tuple_less(lhs, rhs);
+        }
+    };
+};
+
+template <>
+struct select_less<thrust::tuple<size_t, complex<double>>> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (
+            const thrust::tuple<size_t, complex<double>>& lhs, const thrust::tuple<size_t, complex<double>>& rhs) const {
+            return tuple_less(lhs, rhs);
+        }
+    };
+};
+
+template <>
+struct select_less<thrust::tuple<size_t, float>> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (
+            const thrust::tuple<size_t, float>& lhs, const thrust::tuple<size_t, float>& rhs) const {
+            return tuple_less(lhs, rhs);
+        }
+    };
+};
+
+template <>
+struct select_less<thrust::tuple<size_t, double>> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (
+            const thrust::tuple<size_t, double>& lhs, const thrust::tuple<size_t, double>& rhs) const {
+            return tuple_less(lhs, rhs);
+        }
+    };
+};
+
+// floating points
+
+template <>
+struct select_less<float> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (const float& lhs, const float& rhs) const {
+            return real_less(lhs, rhs);
+        }
+    };
+};
+
+template <>
+struct select_less<double> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (const double& lhs, const double& rhs) const {
+            return real_less(lhs, rhs);
+        }
+    };
+};
+
+#ifdef ENABLE_HALF
+template <>
+struct select_less<__half> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (const __half& lhs, const __half& rhs) const {
+            return real_less(lhs, rhs);
+        }
+    };
+};
+
+template <>
+struct select_less<thrust::tuple<size_t, __half>> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (
+            const thrust::tuple<size_t, __half>& lhs, const thrust::tuple<size_t, __half>& rhs) const {
+
+            return tuple_less(lhs, rhs);
+        }
+    };
+};
+#endif  // ENABLE_HALF
+
+/*
+ * -------------------------------------------------- end of boilerplate --------------------------------------------------
+ */
+
+
+/*
+ * sort
+ */
+
+struct _sort {
+    template <typename T>
+    __forceinline__ void operator()(void *data_start, size_t *keys_start,
+                                    const std::vector<ptrdiff_t>& shape, intptr_t stream,
+                                    void* memory) {
+        size_t ndim = shape.size();
+        ptrdiff_t size;
+        thrust::device_ptr<T> dp_data_first, dp_data_last;
+        thrust::device_ptr<size_t> dp_keys_first, dp_keys_last;
+        cudaStream_t stream_ = (cudaStream_t)stream;
+        cupy_allocator alloc(memory);
+
+        // Compute the total size of the array.
+        size = shape[0];
+        for (size_t i = 1; i < ndim; ++i) {
+            size *= shape[i];
+        }
+
+        dp_data_first = thrust::device_pointer_cast(static_cast<T*>(data_start));
+        dp_data_last  = thrust::device_pointer_cast(static_cast<T*>(data_start) + size);
+
+        if (ndim == 1) {
+            // we use thrust::less directly to sort floating points, because then it can use radix sort, which happens to sort NaNs to the back
+            using compare_op = std::conditional_t<std::is_floating_point<T>::value, thrust::less<T>, typename select_less<T>::type>;
+            stable_sort(cuda::par(alloc).on(stream_), dp_data_first, dp_data_last, compare_op{});
+        } else {
+            // Generate key indices.
+            dp_keys_first = thrust::device_pointer_cast(keys_start);
+            dp_keys_last  = thrust::device_pointer_cast(keys_start + size);
+            transform(cuda::par(alloc).on(stream_),
+                      #ifdef __HIP_PLATFORM_HCC__
+                      rocprim::make_counting_iterator<size_t>(0),
+                      rocprim::make_counting_iterator<size_t>(size),
+                      rocprim::make_constant_iterator<ptrdiff_t>(shape[ndim-1]),
+                      #else
+                      thrust::make_counting_iterator<size_t>(0),
+                      thrust::make_counting_iterator<size_t>(size),
+                      thrust::make_constant_iterator<ptrdiff_t>(shape[ndim-1]),
+                      #endif
+                      dp_keys_first,
+                      thrust::divides<size_t>());
+
+            stable_sort(
+                cuda::par(alloc).on(stream_),
+                make_zip_iterator(dp_keys_first, dp_data_first),
+                make_zip_iterator(dp_keys_last, dp_data_last),
+                typename select_less<thrust::tuple<size_t, T>>::type{});
+        }
+    }
+};
+
+
+/*
+ * lexsort
+ */
+
+template <typename T>
+class elem_less {
+public:
+    elem_less(const T *data):_data(data) {}
+    __device__ __forceinline__ bool operator()(size_t i, size_t j) const {
+        return typename select_less<T>::type{}(_data[i], _data[j]);
+    }
+private:
+    const T *_data;
+};
+
+struct _lexsort {
+    template <typename T>
+    __forceinline__ void operator()(size_t *idx_start, void *keys_start, size_t k,
+                                    size_t n, intptr_t stream, void *memory) {
+        /* idx_start is the beginning of the output array where the indexes that
+           would sort the data will be placed. The original contents of idx_start
+           will be destroyed. */
+        thrust::device_ptr<size_t> dp_first = thrust::device_pointer_cast(idx_start);
+        thrust::device_ptr<size_t> dp_last  = thrust::device_pointer_cast(idx_start + n);
+        cudaStream_t stream_ = (cudaStream_t)stream;
+        cupy_allocator alloc(memory);
+        sequence(cuda::par(alloc).on(stream_), dp_first, dp_last);
+        for (size_t i = 0; i < k; ++i) {
+            T *key_start = static_cast<T*>(keys_start) + i * n;
+            stable_sort(
+                cuda::par(alloc).on(stream_),
+                dp_first,
+                dp_last,
+                elem_less<T>(key_start)
+            );
+        }
+    }
+};
+
+
+/*
+ * argsort
+ */
+
+struct _argsort {
+    template <typename T>
+    __forceinline__ void operator()(size_t *idx_start, void *data_start,
+                                    void *keys_start,
+                                    const std::vector<ptrdiff_t>& shape,
+                                    intptr_t stream, void *memory) {
+        /* idx_start is the beginning of the output array where the indexes that
+           would sort the data will be placed. The original contents of idx_start
+           will be destroyed. */
+
+        size_t ndim = shape.size();
+        ptrdiff_t size;
+        cudaStream_t stream_ = (cudaStream_t)stream;
+        cupy_allocator alloc(memory);
+
+        thrust::device_ptr<size_t> dp_idx_first, dp_idx_last;
+        thrust::device_ptr<T> dp_data_first, dp_data_last;
+        thrust::device_ptr<size_t> dp_keys_first, dp_keys_last;
+
+        // Compute the total size of the data array.
+        size = shape[0];
+        for (size_t i = 1; i < ndim; ++i) {
+            size *= shape[i];
+        }
+
+        // Cast device pointers of data.
+        dp_data_first = thrust::device_pointer_cast(static_cast<T*>(data_start));
+        dp_data_last  = thrust::device_pointer_cast(static_cast<T*>(data_start) + size);
+
+        // Generate an index sequence.
+        dp_idx_first = thrust::device_pointer_cast(static_cast<size_t*>(idx_start));
+        dp_idx_last  = thrust::device_pointer_cast(static_cast<size_t*>(idx_start) + size);
+        transform(cuda::par(alloc).on(stream_),
+                  #ifdef __HIP_PLATFORM_HCC__
+                  rocprim::make_counting_iterator<size_t>(0),
+                  rocprim::make_counting_iterator<size_t>(size),
+                  rocprim::make_constant_iterator<ptrdiff_t>(shape[ndim-1]),
+                  #else
+                  thrust::make_counting_iterator<size_t>(0),
+                  thrust::make_counting_iterator<size_t>(size),
+                  thrust::make_constant_iterator<ptrdiff_t>(shape[ndim-1]),
+                  #endif
+                  dp_idx_first,
+                  thrust::modulus<size_t>());
+
+        if (ndim == 1) {
+            // we use thrust::less directly to sort floating points, because then it can use radix sort, which happens to sort NaNs to the back
+            using compare_op = std::conditional_t<std::is_floating_point<T>::value, thrust::less<T>, typename select_less<T>::type>;
+            // Sort the index sequence by data.
+            stable_sort_by_key(cuda::par(alloc).on(stream_),
+                               dp_data_first,
+                               dp_data_last,
+                               dp_idx_first,
+                               compare_op{});
+        } else {
+            // Generate key indices.
+            dp_keys_first = thrust::device_pointer_cast(static_cast<size_t*>(keys_start));
+            dp_keys_last  = thrust::device_pointer_cast(static_cast<size_t*>(keys_start) + size);
+            transform(cuda::par(alloc).on(stream_),
+                      #ifdef __HIP_PLATFORM_HCC__
+                      rocprim::make_counting_iterator<size_t>(0),
+                      rocprim::make_counting_iterator<size_t>(size),
+                      rocprim::make_constant_iterator<ptrdiff_t>(shape[ndim-1]),
+                      #else
+                      thrust::make_counting_iterator<size_t>(0),
+                      thrust::make_counting_iterator<size_t>(size),
+                      thrust::make_constant_iterator<ptrdiff_t>(shape[ndim-1]),
+                      #endif
+                      dp_keys_first,
+                      thrust::divides<size_t>());
+
+            stable_sort_by_key(
+                cuda::par(alloc).on(stream_),
+                make_zip_iterator(dp_keys_first, dp_data_first),
+                make_zip_iterator(dp_keys_last, dp_data_last),
+                dp_idx_first,
+                typename select_less<thrust::tuple<size_t, T>>::type{});
+        }
+    }
+};
+
+
+//
+// APIs exposed to CuPy
+//
+
+/* -------- sort -------- */
+
+void thrust_sort(int dtype_id, void *data_start, size_t *keys_start,
+    const std::vector<ptrdiff_t>& shape, intptr_t stream, void* memory) {
+
+    _sort op;
+    return dtype_dispatcher(dtype_id, op, data_start, keys_start, shape, stream, memory);
+}
+
+
+/* -------- lexsort -------- */
+void thrust_lexsort(int dtype_id, size_t *idx_start, void *keys_start, size_t k,
+    size_t n, intptr_t stream, void *memory) {
+
+    _lexsort op;
+    return dtype_dispatcher(dtype_id, op, idx_start, keys_start, k, n, stream, memory);
+}
+
+
+/* -------- argsort -------- */
+void thrust_argsort(int dtype_id, size_t *idx_start, void *data_start,
+    void *keys_start, const std::vector<ptrdiff_t>& shape, intptr_t stream, void *memory) {
+
+    _argsort op;
+    return dtype_dispatcher(dtype_id, op, idx_start, data_start, keys_start, shape,
+                            stream, memory);
+}
+

vllm/lib/python3.10/site-packages/cupy/cuda/cutensor.py

@@ -0,0 +1,14 @@
+"""
+cuTENSOR Wrapper
+
+Use `cupy_backends.cuda.libs.cutensor` directly in CuPy codebase.
+"""
+
+available = True
+
+try:
+    from cupy_backends.cuda.libs.cutensor import *  # NOQA
+except ImportError as e:
+    available = False
+    from cupy._environment import _preload_warning
+    _preload_warning('cutensor', e)

vllm/lib/python3.10/site-packages/cupy/cuda/memory_hooks/__init__.py

@@ -0,0 +1,6 @@
+from cupy.cuda.memory_hooks import debug_print  # NOQA
+from cupy.cuda.memory_hooks import line_profile  # NOQA
+
+# import class and function
+from cupy.cuda.memory_hooks.debug_print import DebugPrintHook  # NOQA
+from cupy.cuda.memory_hooks.line_profile import LineProfileHook  # NOQA

vllm/lib/python3.10/site-packages/cupy/cuda/memory_hooks/debug_print.py

@@ -0,0 +1,78 @@
+import sys
+
+from cupy.cuda import memory_hook
+
+
+class DebugPrintHook(memory_hook.MemoryHook):
+    """Memory hook that prints debug information.
+
+    This memory hook outputs the debug information of input arguments of
+    ``malloc`` and ``free`` methods involved in the hooked functions
+    at postprocessing time (that is, just after each method is called).
+
+    Example:
+        The basic usage is to use it with ``with`` statement.
+
+        Code example::
+
+            >>> import cupy
+            >>> from cupy.cuda import memory_hooks
+            >>>
+            >>> cupy.cuda.set_allocator(cupy.cuda.MemoryPool().malloc)
+            >>> with memory_hooks.DebugPrintHook():
+            ...     x = cupy.array([1, 2, 3])
+            ...     del x  # doctest:+SKIP
+
+        Output example::
+
+            {"hook":"alloc","device_id":0,"mem_size":512,"mem_ptr":150496608256}
+            {"hook":"malloc","device_id":0,"size":24,"mem_size":512,"mem_ptr":150496608256,"pmem_id":"0x7f39200c5278"}
+            {"hook":"free","device_id":0,"mem_size":512,"mem_ptr":150496608256,"pmem_id":"0x7f39200c5278"}
+
+        where the output format is JSONL (JSON Lines) and
+        ``hook`` is the name of hook point, and
+        ``device_id`` is the CUDA Device ID, and
+        ``size`` is the requested memory size to allocate, and
+        ``mem_size`` is the rounded memory size to be allocated, and
+        ``mem_ptr`` is the memory pointer, and
+        ``pmem_id`` is the pooled memory object ID.
+
+    Attributes:
+        file: Output file_like object that redirect to.
+        flush: If ``True``, this hook forcibly flushes the text stream
+            at the end of print. The default is ``True``.
+
+    """
+
+    name = 'DebugPrintHook'
+
+    def __init__(self, file=sys.stdout, flush=True):
+        self.file = file
+        self.flush = flush
+
+    def _print(self, msg):
+        self.file.write(msg)
+        self.file.write('\n')
+        if self.flush:
+            self.file.flush()
+
+    def alloc_postprocess(self, **kwargs):
+        msg = '{"hook":"%s","device_id":%d,' \
+              '"mem_size":%d,"mem_ptr":%d}'
+        msg %= ('alloc', kwargs['device_id'],
+                kwargs['mem_size'], kwargs['mem_ptr'])
+        self._print(msg)
+
+    def malloc_postprocess(self, **kwargs):
+        msg = '{"hook":"%s","device_id":%d,"size":%d,' \
+              '"mem_size":%d,"mem_ptr":%d,"pmem_id":"%s"}'
+        msg %= ('malloc', kwargs['device_id'], kwargs['size'],
+                kwargs['mem_size'], kwargs['mem_ptr'], hex(kwargs['pmem_id']))
+        self._print(msg)
+
+    def free_postprocess(self, **kwargs):
+        msg = '{"hook":"%s","device_id":%d,' \
+              '"mem_size":%d,"mem_ptr":%d,"pmem_id":"%s"}'
+        msg %= ('free', kwargs['device_id'],
+                kwargs['mem_size'], kwargs['mem_ptr'], hex(kwargs['pmem_id']))
+        self._print(msg)

vllm/lib/python3.10/site-packages/cupy/cuda/memory_hooks/line_profile.py

@@ -0,0 +1,171 @@
+from os import path
+import sys
+import traceback
+
+from cupy.cuda import memory_hook
+
+
+class LineProfileHook(memory_hook.MemoryHook):
+    """Code line CuPy memory profiler.
+
+    This profiler shows line-by-line GPU memory consumption using traceback
+    module. But, note that it can trace only CPython level, no Cython level.
+    ref. https://github.com/cython/cython/issues/1755
+
+    Example:
+        Code example::
+
+            from cupy.cuda import memory_hooks
+            hook = memory_hooks.LineProfileHook()
+            with hook:
+                # some CuPy codes
+            hook.print_report()
+
+        Output example::
+
+            _root (4.00KB, 4.00KB)
+              lib/python3.6/unittest/__main__.py:18:<module> (4.00KB, 4.00KB)
+                lib/python3.6/unittest/main.py:255:runTests (4.00KB, 4.00KB)
+                  tests/cupy_tests/test.py:37:test (1.00KB, 1.00KB)
+                  tests/cupy_tests/test.py:38:test (1.00KB, 1.00KB)
+                  tests/cupy_tests/test.py:39:test (2.00KB, 2.00KB)
+
+        Each line shows::
+
+            {filename}:{lineno}:{func_name} ({used_bytes}, {acquired_bytes})
+
+        where *used_bytes* is the memory bytes used from CuPy memory pool, and
+        *acquired_bytes* is the actual memory bytes the CuPy memory pool
+        acquired from GPU device.
+        *_root* is a root node of the stack trace to show total memory usage.
+
+    Args:
+        max_depth (int): maximum depth to follow stack traces.
+            Default is 0 (no limit).
+    """
+
+    name = 'LineProfileHook'
+
+    def __init__(self, max_depth=0):
+        self._memory_frames = {}
+        self._root = MemoryFrame(None, None)
+        self._filename = path.abspath(__file__)
+        self._max_depth = max_depth
+
+    # callback
+    def malloc_preprocess(self, device_id, size, mem_size):
+        self._create_frame_tree(used_bytes=mem_size)
+
+    # callback
+    def alloc_preprocess(self, device_id, mem_size):
+        self._create_frame_tree(acquired_bytes=mem_size)
+
+    def _create_frame_tree(self, used_bytes=0, acquired_bytes=0):
+        self._root.used_bytes += used_bytes
+        self._root.acquired_bytes += acquired_bytes
+        parent = self._root
+        for depth, stackframe in enumerate(self._extract_stackframes()):
+            if 0 < self._max_depth <= depth + 1:
+                break
+            memory_frame = self._add_frame(parent, stackframe)
+            memory_frame.used_bytes += used_bytes
+            memory_frame.acquired_bytes += acquired_bytes
+            parent = memory_frame
+
+    def _extract_stackframes(self):
+        stackframes = traceback.extract_stack()
+        stackframes = [StackFrame(st) for st in stackframes]
+        stackframes = [
+            st for st in stackframes if st.filename != self._filename]
+        return stackframes
+
+    def _key_frame(self, parent, stackframe):
+        return (parent,
+                stackframe.filename,
+                stackframe.lineno,
+                stackframe.name)
+
+    def _add_frame(self, parent, stackframe):
+        key = self._key_frame(parent, stackframe)
+        if key in self._memory_frames:
+            memory_frame = self._memory_frames[key]
+        else:
+            memory_frame = MemoryFrame(parent, stackframe)
+            self._memory_frames[key] = memory_frame
+        return memory_frame
+
+    def print_report(self, file=sys.stdout):
+        """Prints a report of line memory profiling."""
+        line = '_root (%s, %s)\n' % self._root.humanized_bytes()
+        file.write(line)
+        for child in self._root.children:
+            self._print_frame(child, depth=1, file=file)
+        file.flush()
+
+    def _print_frame(self, memory_frame, depth=0, file=sys.stdout):
+        indent = ' ' * (depth * 2)
+        st = memory_frame.stackframe
+        used_bytes, acquired_bytes = memory_frame.humanized_bytes()
+        line = '%s%s:%s:%s (%s, %s)\n' % (
+            indent, st.filename, st.lineno, st.name,
+            used_bytes, acquired_bytes)
+        file.write(line)
+        for child in memory_frame.children:
+            self._print_frame(child, depth=depth + 1, file=file)
+
+
+class StackFrame(object):
+    """Compatibility layer for outputs of traceback.extract_stack().
+
+    Attributes:
+        filename (string): filename
+        lineno (int): line number
+        name (string): function name
+    """
+
+    def __init__(self, obj):
+        if isinstance(obj, tuple):  # < 3.5
+            self.filename = obj[0]
+            self.lineno = obj[1]
+            self.name = obj[2]
+        else:  # >= 3.5 FrameSummary
+            self.filename = obj.filename
+            self.lineno = obj.lineno
+            self.name = obj.name
+
+
+class MemoryFrame(object):
+    """A single stack frame along with sum of memory usage at the frame.
+
+    Attributes:
+        stackframe (FrameSummary): stackframe from traceback.extract_stack().
+        parent (MemoryFrame): parent frame, that is, caller.
+        children (list of MemoryFrame): child frames, that is, callees.
+        used_bytes (int): memory bytes that users used from CuPy memory pool.
+        acquired_bytes (int): memory bytes that CuPy memory pool acquired
+            from GPU device.
+    """
+
+    def __init__(self, parent, stackframe):
+        self.stackframe = stackframe
+        self.children = []
+        self._set_parent(parent)
+        self.used_bytes = 0
+        self.acquired_bytes = 0
+
+    def humanized_bytes(self):
+        used_bytes = self._humanized_size(self.used_bytes)
+        acquired_bytes = self._humanized_size(self.acquired_bytes)
+        return (used_bytes, acquired_bytes)
+
+    def _set_parent(self, parent):
+        if parent and parent not in parent.children:
+            self.parent = parent
+            parent.children.append(self)
+
+    def _humanized_size(self, size):
+        for unit in ['', 'K', 'M', 'G', 'T', 'P', 'E']:
+            if size < 1024.0:
+                return '%3.2f%sB' % (size, unit)
+            size /= 1024.0
+        return '%.2f%sB' % (size, 'Z')

vllm/lib/python3.10/site-packages/cupy/cuda/nccl.py

@@ -0,0 +1,17 @@
+"""
+NCCL Wrapper
+
+Use `cupy_backends.cuda.libs.nccl` directly in CuPy codebase.
+"""
+
+from cupy import _environment
+
+
+available = True
+
+try:
+    _environment._preload_library('nccl')
+    from cupy_backends.cuda.libs.nccl import *  # NOQA
+except ImportError as e:
+    available = False
+    _environment._preload_warning('nccl', e)

vllm/lib/python3.10/site-packages/cupy/cuda/nvtx.py

@@ -0,0 +1 @@
+from cupy_backends.cuda.libs.nvtx import *  # NOQA

vllm/lib/python3.10/site-packages/cupy/cuda/profiler.py

@@ -0,0 +1,3 @@
+# For backward compatibility only.
+from cupy_backends.cuda.api.runtime import profilerStart as start  # noqa
+from cupy_backends.cuda.api.runtime import profilerStop as stop  # noqa

vllm/lib/python3.10/site-packages/cupy/cuda/runtime.py

@@ -0,0 +1 @@
+from cupy_backends.cuda.api.runtime import *  # NOQA

vllm/lib/python3.10/site-packages/cupy/fft/__init__.py

@@ -0,0 +1,19 @@
+from cupy.fft._fft import fft  # NOQA
+from cupy.fft._fft import fft2  # NOQA
+from cupy.fft._fft import fftfreq  # NOQA
+from cupy.fft._fft import fftn  # NOQA
+from cupy.fft._fft import fftshift  # NOQA
+from cupy.fft._fft import hfft  # NOQA
+from cupy.fft._fft import ifft  # NOQA
+from cupy.fft._fft import ifft2  # NOQA
+from cupy.fft._fft import ifftn  # NOQA
+from cupy.fft._fft import ifftshift  # NOQA
+from cupy.fft._fft import ihfft  # NOQA
+from cupy.fft._fft import irfft  # NOQA
+from cupy.fft._fft import irfft2  # NOQA
+from cupy.fft._fft import irfftn  # NOQA
+from cupy.fft._fft import rfft  # NOQA
+from cupy.fft._fft import rfft2  # NOQA
+from cupy.fft._fft import rfftfreq  # NOQA
+from cupy.fft._fft import rfftn  # NOQA
+from cupy.fft import config  # NOQA

vllm/lib/python3.10/site-packages/cupy/fft/_fft.py

@@ -0,0 +1,1124 @@
+import functools
+import math
+
+import numpy as np
+
+import cupy
+from cupy.fft import config
+from cupy.fft._cache import get_plan_cache
+
+
+_reduce = functools.reduce
+_prod = cupy._core.internal.prod
+
+
+@cupy._util.memoize()
+def _output_dtype(dtype, value_type):
+    if value_type != 'R2C':
+        if dtype in [np.float16, np.float32]:
+            return np.complex64
+        elif dtype not in [np.complex64, np.complex128]:
+            return np.complex128
+    else:
+        if dtype in [np.complex64, np.complex128]:
+            return np.dtype(dtype.char.lower())
+        elif dtype == np.float16:
+            return np.float32
+        elif dtype not in [np.float32, np.float64]:
+            return np.float64
+    return dtype
+
+
+def _convert_dtype(a, value_type):
+    out_dtype = _output_dtype(a.dtype, value_type)
+    if out_dtype != a.dtype:
+        a = a.astype(out_dtype)
+    return a
+
+
+def _cook_shape(a, s, axes, value_type, order='C'):
+    if s is None or s == a.shape:
+        return a
+    if (value_type == 'C2R') and (s[-1] is not None):
+        s = list(s)
+        s[-1] = s[-1] // 2 + 1
+    for sz, axis in zip(s, axes):
+        if (sz is not None) and (sz != a.shape[axis]):
+            shape = list(a.shape)
+            if shape[axis] > sz:
+                index = [slice(None)] * a.ndim
+                index[axis] = slice(0, sz)
+                a = a[tuple(index)]
+            else:
+                index = [slice(None)] * a.ndim
+                index[axis] = slice(0, shape[axis])
+                shape[axis] = sz
+                z = cupy.zeros(shape, a.dtype.char, order=order)
+                z[tuple(index)] = a
+                a = z
+    return a
+
+
+def _convert_fft_type(dtype, value_type):
+    from cupy.cuda import cufft
+
+    if value_type == 'C2C' and dtype == np.complex64:
+        return cufft.CUFFT_C2C
+    elif value_type == 'R2C' and dtype == np.float32:
+        return cufft.CUFFT_R2C
+    elif value_type == 'C2R' and dtype == np.complex64:
+        return cufft.CUFFT_C2R
+    elif value_type == 'C2C' and dtype == np.complex128:
+        return cufft.CUFFT_Z2Z
+    elif value_type == 'R2C' and dtype == np.float64:
+        return cufft.CUFFT_D2Z
+    elif value_type == 'C2R' and dtype == np.complex128:
+        return cufft.CUFFT_Z2D
+    else:
+        raise ValueError
+
+
+def _exec_fft(a, direction, value_type, norm, axis, overwrite_x,
+              out_size=None, out=None, plan=None):
+    from cupy.cuda import cufft
+
+    fft_type = _convert_fft_type(a.dtype, value_type)
+
+    if axis % a.ndim != a.ndim - 1:
+        a = a.swapaxes(axis, -1)
+
+    if a.base is not None or not a.flags.c_contiguous:
+        a = a.copy()
+    elif (
+        not cupy.cuda.runtime.is_hip and
+        value_type == 'C2R' and not overwrite_x
+    ):
+        # The input array may be modified in CUDA 10.1 and above.
+        # See #3763 for the discussion.
+        a = a.copy()
+    elif cupy.cuda.runtime.is_hip and value_type != 'C2C':
+        # hipFFT's R2C would overwrite input
+        # hipFFT's C2R needs a workaround (see below)
+        a = a.copy()
+
+    n = a.shape[-1]
+    if n < 1:
+        raise ValueError(
+            'Invalid number of FFT data points (%d) specified.' % n)
+
+    # Workaround for hipFFT/rocFFT:
+    # Both cuFFT and hipFFT/rocFFT have this requirement that 0-th and
+    # N/2-th element must be real, but cuFFT internally simply ignores it
+    # while hipFFT handles it badly in both Plan1d and PlanNd, so we must
+    # do the correction ourselves to ensure the condition is met.
+    if cupy.cuda.runtime.is_hip and value_type == 'C2R':
+        a[..., 0].imag = 0
+        if out_size is None:
+            a[..., -1].imag = 0
+        elif out_size % 2 == 0:
+            a[..., out_size // 2].imag = 0
+
+    if out_size is None:
+        out_size = n
+
+    batch = a.size // n
+
+    # plan search precedence:
+    # 1. plan passed in as an argument
+    # 2. plan as context manager
+    # 3. cached plan
+    # 4. create a new one
+    curr_plan = cufft.get_current_plan()
+    if curr_plan is not None:
+        if plan is None:
+            plan = curr_plan
+        else:
+            raise RuntimeError('Use the cuFFT plan either as a context manager'
+                               ' or as an argument.')
+
+    if plan is None:
+        devices = None if not config.use_multi_gpus else config._devices
+        # TODO(leofang): do we need to add the current stream to keys?
+        keys = (out_size, fft_type, batch, devices)
+        mgr = config.get_current_callback_manager()
+        if mgr is not None:
+            # to avoid a weird segfault, we generate and cache distinct plans
+            # for every possible (load_aux, store_aux) pairs; the plans are
+            # still generated from the same external Python module
+            load_aux = mgr.cb_load_aux_arr
+            store_aux = mgr.cb_store_aux_arr
+            keys += (mgr.cb_load, mgr.cb_store,
+                     0 if load_aux is None else load_aux.data.ptr,
+                     0 if store_aux is None else store_aux.data.ptr)
+        cache = get_plan_cache()
+        cached_plan = cache.get(keys)
+        if cached_plan is not None:
+            plan = cached_plan
+        elif mgr is None:
+            plan = cufft.Plan1d(out_size, fft_type, batch, devices=devices)
+            cache[keys] = plan
+        else:  # has callback
+            # TODO(leofang): support multi-GPU callback (devices is ignored)
+            if devices:
+                raise NotImplementedError('multi-GPU cuFFT callbacks are not '
+                                          'yet supported')
+            plan = mgr.create_plan(('Plan1d', keys[:-5]))
+            mgr.set_callbacks(plan)
+            cache[keys] = plan
+    else:
+        # check plan validity
+        if not isinstance(plan, cufft.Plan1d):
+            raise ValueError('expected plan to have type cufft.Plan1d')
+        if fft_type != plan.fft_type:
+            raise ValueError('cuFFT plan dtype mismatch.')
+        if out_size != plan.nx:
+            raise ValueError('Target array size does not match the plan.',
+                             out_size, plan.nx)
+        if batch != plan.batch:
+            raise ValueError('Batch size does not match the plan.')
+        if config.use_multi_gpus != (plan.gpus is not None):
+            raise ValueError('Unclear if multiple GPUs are to be used or not.')
+
+    if overwrite_x and value_type == 'C2C':
+        out = a
+    elif out is not None:
+        # verify that out has the expected shape and dtype
+        plan.check_output_array(a, out)
+    else:
+        out = plan.get_output_array(a)
+
+    if batch != 0:
+        plan.fft(a, out, direction)
+
+    sz = out.shape[-1]
+    if fft_type == cufft.CUFFT_R2C or fft_type == cufft.CUFFT_D2Z:
+        sz = n
+    if norm == 'backward' and direction == cufft.CUFFT_INVERSE:
+        out /= sz
+    elif norm == 'ortho':
+        out /= math.sqrt(sz)
+    elif norm == 'forward' and direction == cufft.CUFFT_FORWARD:
+        out /= sz
+
+    if axis % a.ndim != a.ndim - 1:
+        out = out.swapaxes(axis, -1)
+
+    return out
+
+
+def _fft_c2c(a, direction, norm, axes, overwrite_x, plan=None):
+    for axis in axes:
+        a = _exec_fft(a, direction, 'C2C', norm, axis, overwrite_x, plan=plan)
+    return a
+
+
+def _fft(a, s, axes, norm, direction, value_type='C2C', overwrite_x=False,
+         plan=None):
+    if not isinstance(a, cupy.ndarray):
+        raise TypeError('The input array a must be a cupy.ndarray')
+    if (s is not None) and (axes is not None) and len(s) != len(axes):
+        raise ValueError('Shape and axes have different lengths.')
+    if axes is None:
+        if s is None:
+            dim = a.ndim
+        else:
+            dim = len(s)
+        axes = [i for i in range(-dim, 0)]
+    else:
+        axes = tuple(axes)
+    if not axes:
+        if value_type == 'C2C':
+            return a
+        else:
+            raise IndexError('list index out of range')
+    if norm is None:  # for backward compatibility
+        norm = 'backward'
+    # it is important that we check norm after validating axes for NumPy
+    # compatibility: if axes=(), early return is triggered and norm is not
+    # checked...
+    if norm not in ('backward', 'ortho', 'forward'):
+        raise ValueError('Invalid norm value %s, should be "backward", '
+                         '"ortho", or "forward".' % norm)
+    a = _convert_dtype(a, value_type)
+    a = _cook_shape(a, s, axes, value_type)
+
+    if value_type == 'C2C':
+        a = _fft_c2c(a, direction, norm, axes, overwrite_x, plan=plan)
+    elif value_type == 'R2C':
+        a = _exec_fft(a, direction, value_type, norm, axes[-1], overwrite_x)
+        a = _fft_c2c(a, direction, norm, axes[:-1], overwrite_x)
+    else:  # C2R
+        a = _fft_c2c(a, direction, norm, axes[:-1], overwrite_x)
+        # _cook_shape tells us input shape only, and no output shape
+        out_size = _get_fftn_out_size(a.shape, s, axes[-1], value_type)
+        a = _exec_fft(a, direction, value_type, norm, axes[-1], overwrite_x,
+                      out_size)
+
+    return a
+
+
+def _prep_fftn_axes(ndim, s=None, axes=None, value_type='C2C'):
+    """Configure axes argument for an n-dimensional FFT.
+
+    The axes to be transformed are returned in ascending order.
+    """
+
+    # compatibility checks for cupy.cuda.cufft.PlanNd
+    if (s is not None) and (axes is not None) and len(s) != len(axes):
+        raise ValueError("Shape and axes have different lengths.")
+
+    if axes is None:
+        if s is None:
+            dim = ndim
+        else:
+            dim = len(s)
+        axes = tuple([i + ndim for i in range(-dim, 0)])
+        axes_sorted = axes
+    else:
+        axes = tuple(axes)
+        if not axes:
+            return (), ()
+        if _reduce(min, axes) < -ndim or _reduce(max, axes) > ndim - 1:
+            raise ValueError("The specified axes exceed the array dimensions.")
+        if value_type == 'C2C':
+            axes_sorted = tuple(sorted([ax % ndim for ax in axes]))
+        else:  # C2R or R2C
+            # The last axis is special, need to isolate it and append
+            # to the rest of (sorted) axes
+            axes_sorted = sorted([ax % ndim for ax in axes[:-1]])
+            axes_sorted.append(axes[-1] % ndim)
+            axes_sorted = tuple(axes_sorted)
+
+    # unsorted axes for _cook_shape, sorted ones are otherwise used
+    return axes, axes_sorted
+
+
+def _nd_plan_is_possible(axes_sorted, ndim):
+    # PlanNd supports 1D, 2D and 3D batch transforms over contiguous axes
+    # Axes must be contiguous and the first or last axis must be in the axes.
+    return (0 < len(axes_sorted) <= 3
+            and (0 in axes_sorted or (ndim - 1) in axes_sorted)
+            and all((axes_sorted[n + 1] - axes_sorted[n]) == 1
+                    for n in range(len(axes_sorted) - 1)))
+
+
+def _get_cufft_plan_nd(
+        shape, fft_type, axes=None, order='C', out_size=None, to_cache=True):
+    """Generate a CUDA FFT plan for transforming up to three axes.
+
+    Args:
+        shape (tuple of int): The shape of the array to transform
+        fft_type (int): The FFT type to perform. Supported values are:
+            `cufft.CUFFT_C2C`, `cufft.CUFFT_C2R`, `cufft.CUFFT_R2C`,
+            `cufft.CUFFT_Z2Z`, `cufft.CUFFT_Z2D`, and `cufft.CUFFT_D2Z`.
+        axes (None or int or tuple of int):  The axes of the array to
+            transform. Currently, these must be a set of up to three adjacent
+            axes and must include either the first or the last axis of the
+            array.  If `None`, it is assumed that all axes are transformed.
+        order ({'C', 'F'}): Specify whether the data to be transformed has C or
+            Fortran ordered data layout.
+        out_size (int): The output length along the last axis for R2C/C2R FFTs.
+            For C2C FFT, this is ignored (and set to `None`).
+        to_cache (bool): Whether to cache the generated plan. Default is
+            ``True``.
+
+    Returns:
+        plan (cufft.PlanNd): A cuFFT Plan for the chosen `fft_type`.
+    """
+    from cupy.cuda import cufft
+
+    ndim = len(shape)
+
+    if fft_type in (cufft.CUFFT_C2C, cufft.CUFFT_Z2Z):
+        value_type = 'C2C'
+    elif fft_type in (cufft.CUFFT_C2R, cufft.CUFFT_Z2D):
+        value_type = 'C2R'
+    else:  # CUFFT_R2C or CUFFT_D2Z
+        value_type = 'R2C'
+
+    if axes is None:
+        # transform over all axes
+        fft_axes = tuple(range(ndim))
+    else:
+        _, fft_axes = _prep_fftn_axes(ndim, s=None, axes=axes,
+                                      value_type=value_type)
+
+    if not _nd_plan_is_possible(fft_axes, ndim):
+        raise ValueError(
+            "An n-dimensional cuFFT plan could not be created. The axes must "
+            "be contiguous and non-repeating. Between one and three axes can "
+            "be transformed and either the first or last axis must be "
+            "included in axes.")
+
+    if order not in ['C', 'F']:
+        raise ValueError('order must be \'C\' or \'F\'')
+
+    """
+    For full details on idist, istride, iembed, etc. see:
+    http://docs.nvidia.com/cuda/cufft/index.html#advanced-data-layout
+
+    in 1D:
+    input[b * idist + x * istride]
+    output[b * odist + x * ostride]
+
+    in 2D:
+    input[b * idist + (x * inembed[1] + y) * istride]
+    output[b * odist + (x * onembed[1] + y) * ostride]
+
+    in 3D:
+    input[b * idist + ((x * inembed[1] + y) * inembed[2] + z) * istride]
+    output[b * odist + ((x * onembed[1] + y) * onembed[2] + z) * ostride]
+    """
+    # At this point, _default_fft_func() guarantees that for F-order arrays
+    # we only need to consider C2C, and not C2R or R2C.
+    # TODO(leofang): figure out if we really have to skip F-order?
+    in_dimensions = [shape[d] for d in fft_axes]
+    if order == 'F':
+        in_dimensions = in_dimensions[::-1]
+    in_dimensions = tuple(in_dimensions)
+    if fft_type in (cufft.CUFFT_C2C, cufft.CUFFT_Z2Z):
+        out_dimensions = in_dimensions
+        plan_dimensions = in_dimensions
+    else:
+        out_dimensions = list(in_dimensions)
+        if out_size is not None:  # for C2R & R2C
+            out_dimensions[-1] = out_size  # only valid for C order!
+        out_dimensions = tuple(out_dimensions)
+        if fft_type in (cufft.CUFFT_R2C, cufft.CUFFT_D2Z):
+            plan_dimensions = in_dimensions
+        else:  # CUFFT_C2R or CUFFT_Z2D
+            plan_dimensions = out_dimensions
+    inembed = in_dimensions
+    onembed = out_dimensions
+
+    if fft_axes == tuple(range(ndim)):
+        # tranfsorm over all axes
+        nbatch = 1
+        idist = odist = 1  # doesn't matter since nbatch = 1
+        istride = ostride = 1
+    else:
+        # batch along the first or the last axis
+        if 0 not in fft_axes:
+            # don't FFT along the first min_axis_fft axes
+            min_axis_fft = _reduce(min, fft_axes)
+            nbatch = _prod(shape[:min_axis_fft])
+            if order == 'C':
+                # C-ordered GPU array with batch along first dim
+                idist = _prod(in_dimensions)
+                odist = _prod(out_dimensions)
+                istride = 1
+                ostride = 1
+            elif order == 'F':
+                # F-ordered GPU array with batch along first dim
+                idist = 1
+                odist = 1
+                istride = nbatch
+                ostride = nbatch
+        elif (ndim - 1) not in fft_axes:
+            # don't FFT along the last axis
+            num_axes_batch = ndim - len(fft_axes)
+            nbatch = _prod(shape[-num_axes_batch:])
+            if order == 'C':
+                # C-ordered GPU array with batch along last dim
+                idist = 1
+                odist = 1
+                istride = nbatch
+                ostride = nbatch
+            elif order == 'F':
+                # F-ordered GPU array with batch along last dim
+                idist = _prod(in_dimensions)
+                odist = _prod(out_dimensions)
+                istride = 1
+                ostride = 1
+        else:
+            raise ValueError(
+                'General subsets of FFT axes not currently supported for '
+                'GPU case (Can only batch FFT over the first or last '
+                'spatial axes).')
+
+    for n in plan_dimensions:
+        if n < 1:
+            raise ValueError(
+                'Invalid number of FFT data points specified.')
+
+    keys = (plan_dimensions, inembed, istride,
+            idist, onembed, ostride, odist,
+            fft_type, nbatch, order, fft_axes[-1], out_size)
+    mgr = config.get_current_callback_manager()
+    if mgr is not None:
+        # to avoid a weird segfault, we generate and cache distinct plans
+        # for every possible (load_aux, store_aux) pairs; the plans are
+        # still generated from the same external Python module
+        load_aux = mgr.cb_load_aux_arr
+        store_aux = mgr.cb_store_aux_arr
+        keys += (mgr.cb_load, mgr.cb_store,
+                 0 if load_aux is None else load_aux.data.ptr,
+                 0 if store_aux is None else store_aux.data.ptr)
+    cache = get_plan_cache()
+    cached_plan = cache.get(keys)
+    if cached_plan is not None:
+        plan = cached_plan
+    elif mgr is None:
+        plan = cufft.PlanNd(*keys)
+        if to_cache:
+            cache[keys] = plan
+    else:  # has callback
+        plan = mgr.create_plan(('PlanNd', keys[:-4]))
+        mgr.set_callbacks(plan)
+        if to_cache:
+            cache[keys] = plan
+
+    return plan
+
+
+def _get_fftn_out_size(in_shape, s, last_axis, value_type):
+    if value_type == 'C2R':
+        if (s is None) or (s[-1] is None):
+            out_size = 2 * (in_shape[last_axis] - 1)
+        else:
+            out_size = s[-1]
+    elif value_type == 'R2C':
+        out_size = in_shape[last_axis] // 2 + 1
+    else:  # C2C
+        out_size = None
+    return out_size
+
+
+def _exec_fftn(a, direction, value_type, norm, axes, overwrite_x,
+               plan=None, out=None, out_size=None):
+    from cupy.cuda import cufft
+
+    fft_type = _convert_fft_type(a.dtype, value_type)
+
+    if a.flags.c_contiguous:
+        order = 'C'
+    elif a.flags.f_contiguous:
+        order = 'F'
+    else:
+        raise ValueError('a must be contiguous')
+
+    if value_type == 'C2R' and not overwrite_x:
+        # The input array may be modified in CUDA 10.1 and above.
+        # See #3763 for the discussion.
+        a = a.copy()
+    elif cupy.cuda.runtime.is_hip and value_type != 'C2C':
+        # hipFFT's R2C would overwrite input
+        # hipFFT's C2R PlanNd is actually not in use so it's fine here
+        a = a.copy()
+
+    # plan search precedence:
+    # 1. plan passed in as an argument
+    # 2. plan as context manager
+    # 3. cached plan
+    # 4. create a new one
+    curr_plan = cufft.get_current_plan()
+    if curr_plan is not None:
+        plan = curr_plan
+        # don't check repeated usage; it's done in _default_fft_func()
+    if plan is None:
+        # search from cache, and generate a plan if not found
+        plan = _get_cufft_plan_nd(a.shape, fft_type, axes=axes, order=order,
+                                  out_size=out_size)
+    else:
+        if not isinstance(plan, cufft.PlanNd):
+            raise ValueError('expected plan to have type cufft.PlanNd')
+        if order != plan.order:
+            raise ValueError('array orders mismatch (plan: {}, input: {})'
+                             .format(plan.order, order))
+        if a.flags.c_contiguous:
+            expected_shape = [a.shape[ax] for ax in axes]
+            if value_type == 'C2R':
+                expected_shape[-1] = out_size
+        else:
+            # plan.shape will be reversed for Fortran-ordered inputs
+            expected_shape = [a.shape[ax] for ax in axes[::-1]]
+            # TODO(leofang): modify the shape for C2R
+        expected_shape = tuple(expected_shape)
+        if expected_shape != plan.shape:
+            raise ValueError(
+                'The cuFFT plan and a.shape do not match: '
+                'plan.shape = {}, expected_shape={}, a.shape = {}'.format(
+                    plan.shape, expected_shape, a.shape))
+        if fft_type != plan.fft_type:
+            raise ValueError('cuFFT plan dtype mismatch.')
+        if value_type != 'C2C':
+            if axes[-1] != plan.last_axis:
+                raise ValueError('The last axis for R2C/C2R mismatch')
+            if out_size != plan.last_size:
+                raise ValueError('The size along the last R2C/C2R axis '
+                                 'mismatch')
+
+    # TODO(leofang): support in-place transform for R2C/C2R
+    if overwrite_x and value_type == 'C2C':
+        out = a
+    elif out is None:
+        out = plan.get_output_array(a, order=order)
+    else:
+        plan.check_output_array(a, out)
+
+    if out.size != 0:
+        plan.fft(a, out, direction)
+
+    # normalize by the product of the shape along the transformed axes
+    arr = a if fft_type in (cufft.CUFFT_R2C, cufft.CUFFT_D2Z) else out
+    sz = _prod([arr.shape[ax] for ax in axes])
+    if norm == 'backward' and direction == cufft.CUFFT_INVERSE:
+        out /= sz
+    elif norm == 'ortho':
+        out /= math.sqrt(sz)
+    elif norm == 'forward' and direction == cufft.CUFFT_FORWARD:
+        out /= sz
+
+    return out
+
+
+def _fftn(a, s, axes, norm, direction, value_type='C2C', order='A', plan=None,
+          overwrite_x=False, out=None):
+    if not isinstance(a, cupy.ndarray):
+        raise TypeError('The input array a must be a cupy.ndarray')
+    if norm is None:  # for backward compatibility
+        norm = 'backward'
+    if norm not in ('backward', 'ortho', 'forward'):
+        raise ValueError('Invalid norm value %s, should be "backward", '
+                         '"ortho", or "forward".' % norm)
+
+    axes, axes_sorted = _prep_fftn_axes(a.ndim, s, axes, value_type)
+    if not axes_sorted:
+        if value_type == 'C2C':
+            return a
+        else:
+            raise IndexError('list index out of range')
+    a = _convert_dtype(a, value_type)
+
+    if order == 'A':
+        if a.flags.f_contiguous:
+            order = 'F'
+        elif a.flags.c_contiguous:
+            order = 'C'
+        else:
+            a = cupy.ascontiguousarray(a)
+            order = 'C'
+    elif order not in ['C', 'F']:
+        raise ValueError('Unsupported order: {}'.format(order))
+
+    # Note: need to call _cook_shape prior to sorting the axes
+    a = _cook_shape(a, s, axes, value_type, order=order)
+
+    for n in a.shape:
+        if n < 1:
+            raise ValueError(
+                'Invalid number of FFT data points (%d) specified.' % n)
+
+    if order == 'C' and not a.flags.c_contiguous:
+        a = cupy.ascontiguousarray(a)
+    elif order == 'F' and not a.flags.f_contiguous:
+        a = cupy.asfortranarray(a)
+
+    # _cook_shape tells us input shape only, and not output shape
+    out_size = _get_fftn_out_size(a.shape, s, axes_sorted[-1], value_type)
+
+    a = _exec_fftn(a, direction, value_type, norm=norm, axes=axes_sorted,
+                   overwrite_x=overwrite_x, plan=plan, out=out,
+                   out_size=out_size)
+    return a
+
+
+def _default_fft_func(a, s=None, axes=None, plan=None, value_type='C2C'):
+    from cupy.cuda import cufft
+
+    curr_plan = cufft.get_current_plan()
+    if curr_plan is not None:
+        if plan is None:
+            plan = curr_plan
+        else:
+            raise RuntimeError('Use the cuFFT plan either as a context manager'
+                               ' or as an argument.')
+
+    if isinstance(plan, cufft.PlanNd):  # a shortcut for using _fftn
+        return _fftn
+    elif (isinstance(plan, cufft.Plan1d) or
+          a.ndim == 1 or not config.enable_nd_planning):
+        return _fft
+
+    # cuFFT's N-D C2R/R2C transforms may not agree with NumPy's outcomes
+    if a.flags.f_contiguous and value_type != 'C2C':
+        return _fft
+
+    _, axes_sorted = _prep_fftn_axes(a.ndim, s, axes, value_type)
+    if len(axes_sorted) > 1 and _nd_plan_is_possible(axes_sorted, a.ndim):
+        # circumvent two potential hipFFT/rocFFT bugs as of ROCm 3.5.0
+        # TODO(leofang): understand hipFFT better and test newer ROCm versions
+        if cupy.cuda.runtime.is_hip:
+            if (0 == axes_sorted[0] and len(axes_sorted) != a.ndim
+                    and a.flags.c_contiguous):
+                return _fft
+
+            # For C2R, we don't use PlanNd; see the workaround in _exec_fft()
+            if value_type == 'C2R':
+                return _fft
+
+        # prefer Plan1D in the 1D case
+        return _fftn
+    return _fft
+
+
+def fft(a, n=None, axis=-1, norm=None):
+    """Compute the one-dimensional FFT.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        n (None or int): Length of the transformed axis of the output. If ``n``
+            is not given, the length of the input along the axis specified by
+            ``axis`` is used.
+        axis (int): Axis over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``n`` and type
+            will convert to complex if the input is other.
+
+    .. seealso:: :func:`numpy.fft.fft`
+    """
+    from cupy.cuda import cufft
+    return _fft(a, (n,), (axis,), norm, cufft.CUFFT_FORWARD)
+
+
+def ifft(a, n=None, axis=-1, norm=None):
+    """Compute the one-dimensional inverse FFT.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        n (None or int): Length of the transformed axis of the output. If ``n``
+            is not given, the length of the input along the axis specified by
+            ``axis`` is used.
+        axis (int): Axis over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``n`` and type
+            will convert to complex if the input is other.
+
+    .. seealso:: :func:`numpy.fft.ifft`
+    """
+    from cupy.cuda import cufft
+    return _fft(a, (n,), (axis,), norm, cufft.CUFFT_INVERSE)
+
+
+def fft2(a, s=None, axes=(-2, -1), norm=None):
+    """Compute the two-dimensional FFT.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        s (None or tuple of ints): Shape of the transformed axes of the
+            output. If ``s`` is not given, the lengths of the input along the
+            axes specified by ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and type
+            will convert to complex if the input is other.
+
+    .. seealso:: :func:`numpy.fft.fft2`
+    """
+    from cupy.cuda import cufft
+
+    func = _default_fft_func(a, s, axes)
+    return func(a, s, axes, norm, cufft.CUFFT_FORWARD)
+
+
+def ifft2(a, s=None, axes=(-2, -1), norm=None):
+    """Compute the two-dimensional inverse FFT.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        s (None or tuple of ints): Shape of the transformed axes of the
+            output. If ``s`` is not given, the lengths of the input along the
+            axes specified by ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and type
+            will convert to complex if the input is other.
+
+    .. seealso:: :func:`numpy.fft.ifft2`
+    """
+    from cupy.cuda import cufft
+
+    func = _default_fft_func(a, s, axes)
+    return func(a, s, axes, norm, cufft.CUFFT_INVERSE)
+
+
+def fftn(a, s=None, axes=None, norm=None):
+    """Compute the N-dimensional FFT.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        s (None or tuple of ints): Shape of the transformed axes of the
+            output. If ``s`` is not given, the lengths of the input along the
+            axes specified by ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and type
+            will convert to complex if the input is other.
+
+    .. seealso:: :func:`numpy.fft.fftn`
+    """
+    from cupy.cuda import cufft
+
+    func = _default_fft_func(a, s, axes)
+    return func(a, s, axes, norm, cufft.CUFFT_FORWARD)
+
+
+def ifftn(a, s=None, axes=None, norm=None):
+    """Compute the N-dimensional inverse FFT.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        s (None or tuple of ints): Shape of the transformed axes of the
+            output. If ``s`` is not given, the lengths of the input along the
+            axes specified by ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and type
+            will convert to complex if the input is other.
+
+    .. seealso:: :func:`numpy.fft.ifftn`
+    """
+    from cupy.cuda import cufft
+
+    func = _default_fft_func(a, s, axes)
+    return func(a, s, axes, norm, cufft.CUFFT_INVERSE)
+
+
+def rfft(a, n=None, axis=-1, norm=None):
+    """Compute the one-dimensional FFT for real input.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        n (None or int): Number of points along transformation axis in the
+            input to use. If ``n`` is not given, the length of the input along
+            the axis specified by ``axis`` is used.
+        axis (int): Axis over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``n`` and type
+            will convert to complex if the input is other. The length of the
+            transformed axis is ``n//2+1``.
+
+    .. seealso:: :func:`numpy.fft.rfft`
+    """
+    from cupy.cuda import cufft
+
+    return _fft(a, (n,), (axis,), norm, cufft.CUFFT_FORWARD, 'R2C')
+
+
+def irfft(a, n=None, axis=-1, norm=None):
+    """Compute the one-dimensional inverse FFT for real input.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        n (None or int): Length of the transformed axis of the output. For
+            ``n`` output points, ``n//2+1`` input points are necessary. If
+            ``n`` is not given, it is determined from the length of the input
+            along the axis specified by ``axis``.
+        axis (int): Axis over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``n`` and type
+            will convert to complex if the input is other. If ``n`` is not
+            given, the length of the transformed axis is`2*(m-1)` where `m`
+            is the length of the transformed axis of the input.
+
+    .. seealso:: :func:`numpy.fft.irfft`
+    """
+    from cupy.cuda import cufft
+
+    return _fft(a, (n,), (axis,), norm, cufft.CUFFT_INVERSE, 'C2R')
+
+
+def rfft2(a, s=None, axes=(-2, -1), norm=None):
+    """Compute the two-dimensional FFT for real input.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        s (None or tuple of ints): Shape to use from the input. If ``s`` is not
+            given, the lengths of the input along the axes specified by
+            ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and type
+            will convert to complex if the input is other. The length of the
+            last axis transformed will be ``s[-1]//2+1``.
+
+    .. seealso:: :func:`numpy.fft.rfft2`
+    """
+    from cupy.cuda import cufft
+
+    func = _default_fft_func(a, s, axes, value_type='R2C')
+    return func(a, s, axes, norm, cufft.CUFFT_FORWARD, 'R2C')
+
+
+def irfft2(a, s=None, axes=(-2, -1), norm=None):
+    """Compute the two-dimensional inverse FFT for real input.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        s (None or tuple of ints): Shape of the output. If ``s`` is not given,
+            they are determined from the lengths of the input along the axes
+            specified by ``axes``.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and type
+            will convert to complex if the input is other. If ``s`` is not
+            given, the length of final transformed axis of output will be
+            `2*(m-1)` where `m` is the length of the final transformed axis of
+            the input.
+
+    .. seealso:: :func:`numpy.fft.irfft2`
+    """
+    from cupy.cuda import cufft
+
+    func = _default_fft_func(a, s, axes, value_type='C2R')
+    return func(a, s, axes, norm, cufft.CUFFT_INVERSE, 'C2R')
+
+
+def rfftn(a, s=None, axes=None, norm=None):
+    """Compute the N-dimensional FFT for real input.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        s (None or tuple of ints): Shape to use from the input. If ``s`` is not
+            given, the lengths of the input along the axes specified by
+            ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and type
+            will convert to complex if the input is other. The length of the
+            last axis transformed will be ``s[-1]//2+1``.
+
+    .. seealso:: :func:`numpy.fft.rfftn`
+    """
+    from cupy.cuda import cufft
+
+    func = _default_fft_func(a, s, axes, value_type='R2C')
+    return func(a, s, axes, norm, cufft.CUFFT_FORWARD, 'R2C')
+
+
+def _size_last_transform_axis(shape, s, axes):
+    if s is not None:
+        if s[-1] is not None:
+            return s[-1]
+    elif axes is not None:
+        return shape[axes[-1]]
+    return shape[-1]
+
+
+def irfftn(a, s=None, axes=None, norm=None):
+    """Compute the N-dimensional inverse FFT for real input.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        s (None or tuple of ints): Shape of the output. If ``s`` is not given,
+            they are determined from the lengths of the input along the axes
+            specified by ``axes``.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``s`` and type
+            will convert to complex if the input is other. If ``s`` is not
+            given, the length of final transformed axis of output will be
+            ``2*(m-1)`` where `m` is the length of the final transformed axis
+            of the input.
+
+    .. seealso:: :func:`numpy.fft.irfftn`
+    """
+    from cupy.cuda import cufft
+
+    func = _default_fft_func(a, s, axes, value_type='C2R')
+    return func(a, s, axes, norm, cufft.CUFFT_INVERSE, 'C2R')
+
+
+def _swap_direction(norm):
+    if norm in (None, 'backward'):
+        norm = 'forward'
+    elif norm == 'forward':
+        norm = 'backward'
+    elif norm != 'ortho':
+        raise ValueError('Invalid norm value %s; should be "backward", '
+                         '"ortho", or "forward".' % norm)
+    return norm
+
+
+def hfft(a, n=None, axis=-1, norm=None):
+    """Compute the FFT of a signal that has Hermitian symmetry.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        n (None or int): Length of the transformed axis of the output. For
+            ``n`` output points, ``n//2+1`` input points are necessary. If
+            ``n`` is not given, it is determined from the length of the input
+            along the axis specified by ``axis``.
+        axis (int): Axis over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``n`` and type
+            will convert to complex if the input is other. If ``n`` is not
+            given, the length of the transformed axis is ``2*(m-1)`` where `m`
+            is the length of the transformed axis of the input.
+
+    .. seealso:: :func:`numpy.fft.hfft`
+    """
+    return irfft(a.conj(), n, axis, _swap_direction(norm))
+
+
+def ihfft(a, n=None, axis=-1, norm=None):
+    """Compute the FFT of a signal that has Hermitian symmetry.
+
+    Args:
+        a (cupy.ndarray): Array to be transform.
+        n (None or int): Number of points along transformation axis in the
+            input to use. If ``n`` is not given, the length of the input along
+            the axis specified by ``axis`` is used.
+        axis (int): Axis over which to compute the FFT.
+        norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
+            to specify the normalization mode. Default is ``None``, which is
+            an alias of ``"backward"``.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``n`` and type
+            will convert to complex if the input is other. The length of the
+            transformed axis is ``n//2+1``.
+
+    .. seealso:: :func:`numpy.fft.ihfft`
+    """
+    return rfft(a, n, axis, _swap_direction(norm)).conj()
+
+
+def fftfreq(n, d=1.0):
+    """Return the FFT sample frequencies.
+
+    Args:
+        n (int): Window length.
+        d (scalar): Sample spacing.
+
+    Returns:
+        cupy.ndarray: Array of length ``n`` containing the sample frequencies.
+
+    .. seealso:: :func:`numpy.fft.fftfreq`
+    """
+    return cupy.hstack((cupy.arange(0, (n - 1) // 2 + 1, dtype=np.float64),
+                        cupy.arange(-(n // 2), 0, dtype=np.float64))) / (n * d)
+
+
+def rfftfreq(n, d=1.0):
+    """Return the FFT sample frequencies for real input.
+
+    Args:
+        n (int): Window length.
+        d (scalar): Sample spacing.
+
+    Returns:
+        cupy.ndarray:
+            Array of length ``n//2+1`` containing the sample frequencies.
+
+    .. seealso:: :func:`numpy.fft.rfftfreq`
+    """
+    return cupy.arange(0, n // 2 + 1, dtype=np.float64) / (n * d)
+
+
+def fftshift(x, axes=None):
+    """Shift the zero-frequency component to the center of the spectrum.
+
+    Args:
+        x (cupy.ndarray): Input array.
+        axes (int or tuple of ints): Axes over which to shift. Default is
+            ``None``, which shifts all axes.
+
+    Returns:
+        cupy.ndarray: The shifted array.
+
+    .. seealso:: :func:`numpy.fft.fftshift`
+    """
+    x = cupy.asarray(x)
+    if axes is None:
+        axes = list(range(x.ndim))
+    elif isinstance(axes, int):
+        axes = (axes,)
+    return cupy.roll(x, [x.shape[axis] // 2 for axis in axes], axes)
+
+
+def ifftshift(x, axes=None):
+    """The inverse of :meth:`fftshift`.
+
+    Args:
+        x (cupy.ndarray): Input array.
+        axes (int or tuple of ints): Axes over which to shift. Default is
+            ``None``, which shifts all axes.
+
+    Returns:
+        cupy.ndarray: The shifted array.
+
+    .. seealso:: :func:`numpy.fft.ifftshift`
+    """
+    x = cupy.asarray(x)
+    if axes is None:
+        axes = list(range(x.ndim))
+    elif isinstance(axes, int):
+        axes = (axes,)
+    return cupy.roll(x, [-(x.shape[axis] // 2) for axis in axes], axes)

vllm/lib/python3.10/site-packages/cupy/fft/config.py

@@ -0,0 +1,61 @@
+from cupy import _util
+
+# expose cache handles to this module
+from cupy.fft._cache import get_plan_cache  # NOQA
+from cupy.fft._cache import clear_plan_cache  # NOQA
+from cupy.fft._cache import get_plan_cache_size  # NOQA
+from cupy.fft._cache import set_plan_cache_size  # NOQA
+from cupy.fft._cache import get_plan_cache_max_memsize  # NOQA
+from cupy.fft._cache import set_plan_cache_max_memsize  # NOQA
+from cupy.fft._cache import show_plan_cache_info  # NOQA
+
+# on Linux, expose callback handles to this module
+import sys as _sys
+if _sys.platform.startswith('linux'):
+    from cupy.fft._callback import get_current_callback_manager  # NOQA
+    from cupy.fft._callback import set_cufft_callbacks  # NOQA
+else:
+    def get_current_callback_manager(*args, **kwargs):
+        return None
+
+    class set_cufft_callbacks:  # type: ignore
+        def __init__(self, *args, **kwargs):
+            raise RuntimeError('cuFFT callback is only available on Linux')
+
+
+enable_nd_planning = True
+use_multi_gpus = False
+_devices = None
+
+
+def set_cufft_gpus(gpus):
+    '''Set the GPUs to be used in multi-GPU FFT.
+
+    Args:
+        gpus (int or list of int): The number of GPUs or a list of GPUs
+            to be used. For the former case, the first ``gpus`` GPUs
+            will be used.
+
+    .. warning::
+        This API is currently experimental and may be changed in the future
+        version.
+
+    .. seealso:: `Multiple GPU cuFFT Transforms`_
+
+    .. _Multiple GPU cuFFT Transforms:
+        https://docs.nvidia.com/cuda/cufft/index.html#multiple-GPU-cufft-transforms
+    '''
+    _util.experimental('cupy.fft.config.set_cufft_gpus')
+    global _devices
+
+    if isinstance(gpus, int):
+        devs = [i for i in range(gpus)]
+    elif isinstance(gpus, list):
+        devs = gpus
+    else:
+        raise ValueError("gpus must be an int or a list of int.")
+    if len(devs) <= 1:
+        raise ValueError("Must use at least 2 GPUs.")
+
+    # make it hashable
+    _devices = tuple(devs)

vllm/lib/python3.10/site-packages/cupy/lib/__init__.py

@@ -0,0 +1 @@
+from cupy.lib import stride_tricks  # NOQA