[feature] Add Custom Op grouped_matmul_swiglu_quant (#4431)

This PR introduces the `EXEC_NPU_CMD` macro, serving as an adapter layer
to simplify the invocation of `aclnn` operators on Ascend NPUs.

**Key Changes:**
* **Adapter Layer:** Added `EXEC_NPU_CMD` macro and related dependencies
to standardize `aclnn` calls.
* **Operator Support:** Integrated `grouped_matmul_swiglu_quant` as a
reference implementation to demonstrate the usage of the new macro.

---


- vLLM version: v0.11.2

---------

Signed-off-by: SlightwindSec <[email protected]>

Author: SlightwindSec

.github/workflows/release_whl.yml

@@ -98,6 +98,7 @@ jobs:
           --exclude libc_sec.so \
           --exclude "libascend*.so" \
           --exclude "libtorch*.so" \
+          --exclude "libopapi.so" \
           --exclude "liberror_manager.so"
         done
         rm -f dist/*.whl

CMakeLists.txt

@@ -63,7 +63,8 @@ ascendc_library(vllm_ascend_kernels SHARED
 message("TORCH_NPU_PATH is ${TORCH_NPU_PATH}")
 
 file(GLOB VLLM_ASCEND_SRC
-${CMAKE_CURRENT_SOURCE_DIR}/csrc/*.cpp)
+${CMAKE_CURRENT_SOURCE_DIR}/csrc/*.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/csrc/aclnn_torch_adapter/*.cpp)
 
 include_directories(
   ${pybind11_INCLUDE_DIRS}
@@ -88,6 +89,7 @@ pybind11_add_module(vllm_ascend_C ${VLLM_ASCEND_SRC})
 target_link_directories(
   vllm_ascend_C
   PRIVATE
+  ${TORCH_LIBRARY_DIRS}
   ${TORCH_NPU_PATH}/lib/
   ${ASCEND_HOME_PATH}/lib64
 )
@@ -96,14 +98,15 @@ target_link_libraries(
   vllm_ascend_C
   PUBLIC
   ${TORCH_LIBRARIES}
-  libtorch_npu.so
+  torch_npu
   vllm_ascend_kernels
   ascendcl
   tiling_api
   register
   platform
   ascendalog
   dl
+  opapi
 )
 
 target_link_options(vllm_ascend_C PRIVATE "-Wl,-rpath,$ORIGIN:$ORIGIN/lib")

csrc/aclnn_torch_adapter/NPUBridge.cpp

@@ -0,0 +1,30 @@
+// Copyright (c) 2020, Huawei Technologies Co., Ltd
+// All rights reserved.
+//
+// This source code is licensed under the BSD-style license found in the
+// LICENSE file in the root directory of this source tree.
+
+#include "NPUBridge.h"
+
+namespace vllm_ascend
+{
+    NPUStorageImpl *NPUBridge::GetNpuStorageImpl(c10::StorageImpl *storageImpl)
+    {
+        return static_cast<NPUStorageImpl *>(storageImpl);
+    }
+
+    NPUStorageImpl *NPUBridge::GetNpuStorageImpl(c10::Storage &&storage)
+    {
+        return static_cast<NPUStorageImpl *>(storage.unsafeGetStorageImpl());
+    }
+
+    NPUStorageImpl *NPUBridge::GetNpuStorageImpl(const at::Tensor &tensor)
+    {
+        return static_cast<NPUStorageImpl *>(tensor.storage().unsafeGetStorageImpl());
+    }
+
+    NPUStorageDesc &NPUBridge::GetNpuStorageImplDesc(const at::Tensor &tensor)
+    {
+        return static_cast<NPUStorageImpl *>(tensor.storage().unsafeGetStorageImpl())->npu_desc_;
+    }
+}

csrc/aclnn_torch_adapter/NPUBridge.h

@@ -0,0 +1,29 @@
+// Copyright (c) 2020, Huawei Technologies Co., Ltd
+// All rights reserved.
+//
+// This source code is licensed under the BSD-style license found in the
+// LICENSE file in the root directory of this source tree.
+
+#pragma once
+#include <c10/core/StorageImpl.h>
+#include "NPUStorageImpl.h"
+
+namespace vllm_ascend
+{
+
+    class NPUBridge
+    {
+    public:
+        // at::tensor to NPUStorageImpl
+        static NPUStorageImpl *GetNpuStorageImpl(const at::Tensor &tensor);
+
+        // c10::StorageImpl to NPUStorageImpl
+        static NPUStorageImpl *GetNpuStorageImpl(c10::StorageImpl *storageImpl);
+
+        // c10::Storage to NPUStorageImpl
+        static NPUStorageImpl *GetNpuStorageImpl(c10::Storage &&storage);
+
+        // tensor to NPUStorageDesc
+        static NPUStorageDesc &GetNpuStorageImplDesc(const at::Tensor &tensor);
+    };
+}

csrc/aclnn_torch_adapter/NPUStorageImpl.cpp

@@ -0,0 +1,52 @@
+// Copyright (c) 2020, Huawei Technologies Co., Ltd
+// All rights reserved.
+//
+// This source code is licensed under the BSD-style license found in the
+// LICENSE file in the root directory of this source tree.
+
+#include "NPUStorageImpl.h"
+
+namespace vllm_ascend
+{
+
+    NPUStorageImpl::NPUStorageImpl(
+        use_byte_size_t use_byte_size,
+        size_t size_bytes,
+        at::DataPtr data_ptr,
+        at::Allocator *allocator,
+        bool resizable) : c10::StorageImpl(use_byte_size,
+                                           size_bytes,
+                                           at::DataPtr(std::move(data_ptr)),
+                                           allocator,
+                                           resizable)
+    {
+    }
+
+    void NPUStorageImpl::release_resources()
+    {
+        StorageImpl::release_resources();
+    }
+
+    c10::intrusive_ptr<c10::StorageImpl> make_npu_storage_impl(
+        c10::StorageImpl::use_byte_size_t,
+        c10::SymInt size_bytes,
+        c10::DataPtr data_ptr,
+        c10::Allocator *allocator,
+        bool resizable)
+    {
+        if (data_ptr == nullptr)
+        {
+            data_ptr = allocator->allocate(size_bytes.as_int_unchecked());
+        }
+        // Correctly create NPUStorageImpl object.
+        c10::intrusive_ptr<c10::StorageImpl> npu_storage_impl = c10::make_intrusive<NPUStorageImpl>(
+            c10::StorageImpl::use_byte_size_t(),
+            size_bytes.as_int_unchecked(),
+            std::move(data_ptr),
+            allocator,
+            resizable);
+        // There is no need to consider the NPUStorageDesc information, it will be carried out in the subsequent processing.
+        return npu_storage_impl;
+    }
+
+}

csrc/aclnn_torch_adapter/NPUStorageImpl.h

@@ -0,0 +1,67 @@
+// Copyright (c) 2020, Huawei Technologies Co., Ltd
+// All rights reserved.
+//
+// This source code is licensed under the BSD-style license found in the
+// LICENSE file in the root directory of this source tree.
+
+#pragma once
+
+#include <ATen/Tensor.h>
+#include <c10/core/StorageImpl.h>
+#include <c10/core/Allocator.h>
+#include <c10/core/ScalarType.h>
+#include <c10/util/typeid.h>
+#include <c10/util/order_preserving_flat_hash_map.h>
+
+#include "acl/acl_rt.h"
+#include "acl/acl_base.h"
+
+namespace vllm_ascend
+{
+
+    struct NPUStorageDesc
+    {
+    public:
+        struct use_byte_size_t
+        {
+        };
+
+        c10::SmallVector<int64_t, 5> base_sizes_;
+        c10::SmallVector<int64_t, 5> base_strides_;
+        c10::SmallVector<int64_t, 5> storage_sizes_;
+        int64_t base_offset_ = 0;
+        use_byte_size_t base_dtype_ = {};
+        aclFormat origin_format_ = ACL_FORMAT_UNDEFINED;
+        aclFormat npu_format_ = ACL_FORMAT_ND;
+        // used to make CANN GE tensor from storagImpl
+        caffe2::TypeMeta data_type_ = caffe2::TypeMeta::Make<uint8_t>();
+    };
+
+    struct NPUStorageImpl : public c10::StorageImpl
+    {
+        explicit NPUStorageImpl(
+            use_byte_size_t use_byte_size,
+            size_t size_bytes,
+            at::DataPtr data_ptr,
+            at::Allocator *allocator,
+            bool resizable);
+        ~NPUStorageImpl() override = default;
+
+        void release_resources() override;
+
+        NPUStorageDesc npu_desc_;
+
+        NPUStorageDesc get_npu_desc() const
+        {
+            return npu_desc_;
+        }
+    };
+
+    c10::intrusive_ptr<c10::StorageImpl> make_npu_storage_impl(
+        c10::StorageImpl::use_byte_size_t,
+        c10::SymInt size_bytes,
+        c10::DataPtr data_ptr,
+        c10::Allocator *allocator,
+        bool resizable);
+
+}