mindspore 2.4.0__cp310-cp310-manylinux1_x86_64.whl → 2.4.1__cp310-cp310-manylinux1_x86_64.whl

mindspore/.commit_id

@@ -1 +1 @@
-__commit_id__ = '[sha1]:8c86f33f,[branch]:(HEAD,origin/master,origin/HEAD,master)'
+__commit_id__ = '[sha1]:01847825,[branch]:(HEAD,origin/r2.4.1,r2.4.1)'

mindspore/common/initializer.py

@@ -103,6 +103,12 @@ def _numpy_seed():
     return np.random.randint(low=1, high=(1 << 63), dtype=np.int64)
 
 
+def _init_random_normal_inplace(mean, sigma, arr):
+    if sigma < 0:
+        raise ValueError("sigma < 0")
+    _random_normal(_numpy_seed(), arr, mean, sigma)
+
+
 def _init_random_normal(mean, sigma, shape):
     if sigma < 0:
         raise ValueError("sigma < 0")
@@ -111,12 +117,22 @@ def _init_random_normal(mean, sigma, shape):
     return data
 
 
+def _init_random_uniform_inplace(a, b, arr):
+    _random_uniform(_numpy_seed(), arr, a, b)
+
+
 def _init_random_uniform(a, b, shape):
     data = np.ndarray(shape=shape, dtype=np.float32)
     _random_uniform(_numpy_seed(), data, a, b)
     return data
 
 
+def _init_truncated_normal_inplace(a, b, mean, sigma, arr):
+    if sigma < 0:
+        raise ValueError("sigma < 0")
+    _truncated_normal(_numpy_seed(), arr, a, b, mean, sigma)
+
+
 def _init_truncated_normal(a, b, mean, sigma, shape):
     if sigma < 0:
         raise ValueError("sigma < 0")
@@ -298,9 +314,11 @@ class XavierNormal(Initializer):
         fan_in, fan_out = _calculate_fan_in_and_fan_out(arr.shape)
 
         std = self.gain * math.sqrt(2.0 / float(fan_in + fan_out))
-        data = _init_random_normal(0, std, arr.shape)
-
-        _assignment(arr, data)
+        if isinstance(arr, np.ndarray) and arr.dtype == np.float32:
+            _init_random_normal_inplace(0, std, arr)
+        else:
+            data = _init_random_normal(0, std, arr.shape)
+            _assignment(arr, data)
 
 
 @_register('xavier_uniform')
@@ -337,8 +355,11 @@ class XavierUniform(Initializer):
     def _initialize(self, arr):
         n_in, n_out = _calculate_fan_in_and_fan_out(arr.shape)
         boundary = self.gain * math.sqrt(6.0 / (n_in + n_out))
-        data = _init_random_uniform(-boundary, boundary, arr.shape)
-        _assignment(arr, data)
+        if isinstance(arr, np.ndarray) and arr.dtype == np.float32:
+            _init_random_uniform_inplace(-boundary, boundary, arr)
+        else:
+            data = _init_random_uniform(-boundary, boundary, arr.shape)
+            _assignment(arr, data)
 
 
 @_register('he_uniform')
@@ -386,8 +407,11 @@ class HeUniform(Initializer):
         gain = _calculate_gain(self.nonlinearity, self.negative_slope)
         std = gain / math.sqrt(fan)
         boundary = math.sqrt(3.0) * std
-        data = _init_random_uniform(-boundary, boundary, arr.shape)
-        _assignment(arr, data)
+        if isinstance(arr, np.ndarray) and arr.dtype == np.float32:
+            _init_random_uniform_inplace(-boundary, boundary, arr)
+        else:
+            data = _init_random_uniform(-boundary, boundary, arr.shape)
+            _assignment(arr, data)
 
 
 @_register('he_normal')
@@ -432,8 +456,11 @@ class HeNormal(Initializer):
         fan = _calculate_correct_fan(arr.shape, self.mode)
         gain = _calculate_gain(self.nonlinearity, self.negative_slope)
         std = gain / math.sqrt(fan)
-        data = _init_random_normal(0, std, arr.shape)
-        _assignment(arr, data)
+        if isinstance(arr, np.ndarray) and arr.dtype == np.float32:
+            _init_random_normal_inplace(0, std, arr)
+        else:
+            data = _init_random_normal(0, std, arr.shape)
+            _assignment(arr, data)
 
 
 class Constant(Initializer):
@@ -718,8 +745,11 @@ class Uniform(Initializer):
         self.scale = scale
 
     def _initialize(self, arr):
-        tmp = _init_random_uniform(-self.scale, self.scale, arr.shape)
-        _assignment(arr, tmp)
+        if isinstance(arr, np.ndarray) and arr.dtype == np.float32:
+            _init_random_uniform_inplace(-self.scale, self.scale, arr)
+        else:
+            tmp = _init_random_uniform(-self.scale, self.scale, arr.shape)
+            _assignment(arr, tmp)
 
 
 @_register()
@@ -749,8 +779,11 @@ class Normal(Initializer):
         self.mean = mean
 
     def _initialize(self, arr):
-        data = _init_random_normal(self.mean, self.sigma, arr.shape)
-        _assignment(arr, data)
+        if isinstance(arr, np.ndarray) and arr.dtype == np.float32:
+            _init_random_normal_inplace(self.mean, self.sigma, arr)
+        else:
+            data = _init_random_normal(self.mean, self.sigma, arr.shape)
+            _assignment(arr, data)
 
 
 @_register()
@@ -780,8 +813,11 @@ class TruncatedNormal(Initializer):
         self.b = b
 
     def _initialize(self, arr):
-        tmp = _init_truncated_normal(self.a, self.b, self.mean, self.sigma, arr.shape)
-        _assignment(arr, tmp)
+        if isinstance(arr, np.ndarray) and arr.dtype == np.float32:
+            _init_truncated_normal_inplace(self.a, self.b, self.mean, self.sigma, arr)
+        else:
+            tmp = _init_truncated_normal(self.a, self.b, self.mean, self.sigma, arr.shape)
+            _assignment(arr, tmp)
 
 
 def initializer(init, shape=None, dtype=mstype.float32):

mindspore/common/parameter.py

@@ -22,6 +22,7 @@ import os
 import sys
 import math
 import numbers
+from contextlib import contextmanager
 import numpy as np
 from mindspore import log as logger
 from mindspore.log import _LogActionOnce
@@ -54,6 +55,16 @@ PARAMETER_NAME_PREFIX_MAX_LEN = 1024
 _GLOBAL_PARAMETER_KEY = -1
 
 
+@contextmanager
+def no_init_parameters():
+    init_class = globals()["Parameter"]
+    setattr(init_class, "init_param", False)
+    try:
+        yield
+    finally:
+        setattr(init_class, "init_param", True)
+
+
 def _is_in_auto_parallel_mode():
     """Get parallel mode."""
     return auto_parallel_context().get_parallel_mode() in ["semi_auto_parallel", "auto_parallel"]
@@ -243,7 +254,8 @@ class Parameter(Tensor_):
     def __new__(cls, default_input, *args, **kwargs):
         init_data_flag = bool(isinstance(default_input, Tensor) and default_input.has_init)
         rc = sys.getrefcount(default_input)
-        input_class, *class_init_args = Parameter._get_parameter_new_args(default_input, rc)
+        init_param = getattr(cls, "init_param", True)
+        input_class, *class_init_args = Parameter._get_parameter_new_args(default_input, rc, init_param)
         new_type = Parameter._get_base_class(input_class)
         obj = input_class.__new__(new_type)
         input_class.__init__(obj, *class_init_args)
@@ -355,7 +367,7 @@ class Parameter(Tensor_):
         return new_type
 
     @staticmethod
-    def _get_parameter_new_args(data, rc):
+    def _get_parameter_new_args(data, rc, init_param=True):
         """Set `set_data` of current `Parameter`."""
         if isinstance(data, bool):
             raise ValueError('Parameter data can not be `bool`')
@@ -370,8 +382,8 @@ class Parameter(Tensor_):
                     return (Tensor, data.asnumpy(), mstype.qint4x2)
                 return (Tensor, data.asnumpy())
 
-            not_init_data = _is_role_sched() or (_is_role_pserver() and _cache_enable()
-                                                 ) or _is_in_auto_parallel_mode() or _is_parallel_mode()
+            not_init_data = not init_param or _is_role_sched() or (_is_role_pserver() and _cache_enable()) \
+                            or _is_in_auto_parallel_mode() or _is_parallel_mode()
             if not_init_data:
                 # do not init data while in auto parallel.
                 return (Tensor, None, data.dtype, get_slice_shape(data.dtype, data.shape), data.init)
@@ -976,6 +988,8 @@ class Parameter(Tensor_):
         """
         if self.is_default_input_init and self.is_in_parallel != _is_in_auto_parallel_mode():
             raise RuntimeError("Must set or change parallel mode before any initializer Tensor created.")
+        if hasattr(self, "init_param") and self.init_param:
+            return self
         if self.init_mode is None:
             return self
         if self.inited_param is not None:

mindspore/common/tensor.py

@@ -2896,8 +2896,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             self.slice_shape_of_persistent_data_ = data_shape
             self.slice_num_of_persistent_data_ = slice_num_of_persistent_data
 
+        from mindspore.common.initializer import Zero as ZeroInitializer
+
         try:
-            data = np.ndarray(data_shape, dtype=mstype.dtype_to_nptype(self.dtype))
+            if isinstance(self.init, ZeroInitializer):
+                data = np.zeros(data_shape, dtype=mstype.dtype_to_nptype(self.dtype))
+            else:
+                data = np.ndarray(data_shape, dtype=mstype.dtype_to_nptype(self.dtype))
         except ValueError as e:
             msg = "Error shape={}".format(shape)
             logger.critical(msg)
@@ -2933,7 +2938,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                     self.init.seed, _ = self.seed
 
         with seed_context(self.init):
-            if slice_num_of_persistent_data == 1:
+            if not isinstance(self.init, ZeroInitializer) and slice_num_of_persistent_data == 1:
                 self.init(data)
         self.init = None
 
@@ -4749,7 +4754,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('lu_solve')(self, LU_data, LU_pivots)
 
-
     def nextafter(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.nextafter`.
@@ -4763,7 +4767,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         validator.check_value_type('some', some, bool, 'Tensor.qr')
         return tensor_operator_registry.get('qr')(self, 'reduced' if some else 'complete')
 
-
     def ormqr(self, input2, input3, left=True, transpose=False):
         r"""
         For details, please refer to :func:`mindspore.ops.ormqr`,
@@ -4771,7 +4774,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('ormqr')(self, input2, input3, left, transpose)
 
-
     def masked_scatter(self, mask, x):
         r"""
         Returns a Tensor. Updates the value in the "self Tensor" with the `tensor` value according to the mask.
@@ -4812,7 +4814,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('masked_scatter')()(self, mask, x)
 
-
     def index_put(self, indices, values, accumulate=False):
         r"""
         Returns a Tensor. According to the index number of `indices` ,
@@ -4865,7 +4866,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         _index_put = tensor_operator_registry.get('index_put')(0 if accumulate is False else 1)
         return _index_put(self, values, indices)
 
-
     def move_to(self, to, blocking=True):
         r"""
         Copy Tensor to target device synchronously or asynchronously, default synchronously. only support PyNative mode.
@@ -4899,8 +4899,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         mode = context.get_context("mode")
         if mode != context.PYNATIVE_MODE:
             raise ValueError(f"The method of 'move_to' only supported in pynative mode, but got: {mode}.")
-        return Tensor(Tensor_.move_to(self, to, blocking), device="CPU" if to == "CPU" else None)
-
+        return Tensor_.move_to(self, to, blocking)
 
     def _offload(self):
         r"""
@@ -4946,44 +4945,6 @@ def _vm_compare(*args):
     return Tensor(np.array(fn(y)))
 
 
-def _check_sequence_shape(input_data):
-    """Check the shape of tensor input with type of sequence."""
-    max_dims_reached = False
-    max_ndim = 64 # corresponding to NPY_MAXDIMS
-    out_shape = [0]*max_ndim
-
-    def check_shape_recursive(input_data, curr_ndim):
-        nonlocal max_dims_reached, max_ndim, out_shape
-        if curr_ndim > max_ndim:
-            return False
-        if not isinstance(input_data, (tuple, list)):
-            if max_dims_reached and curr_ndim != max_ndim:
-                max_ndim = curr_ndim
-                return False
-            max_dims_reached = True
-            max_ndim = curr_ndim
-            return True
-        if not max_dims_reached:
-            out_shape[curr_ndim] = len(input_data)
-        else:
-            if out_shape[curr_ndim] != len(input_data):
-                max_ndim = curr_ndim
-                return False
-        if not input_data:
-            # process empty list
-            if not check_shape_recursive(None, curr_ndim + 1):
-                return False
-        for data in input_data:
-            if not check_shape_recursive(data, curr_ndim + 1):
-                return False
-        return True
-
-    if not check_shape_recursive(input_data, 0):
-        raise ValueError(f"When initializing a tensor with a sequence, the sequence has an inhomogeneous shape "
-                         f"after {max_ndim} dimensions. The detected shape was {tuple(out_shape[:max_ndim])} "
-                         f"+ inhomogeneous part.")
-
-
 def _check_tensor_input(input_data=None, dtype=None, shape=None, init=None):
     """Check the tensor input."""
     if input_data is not None and shape is not None:
@@ -4997,8 +4958,13 @@ def _check_tensor_input(input_data=None, dtype=None, shape=None, init=None):
         if isinstance(input_data, np.ndarray) and input_data.ndim >= 1 and input_data.size == 0:
             raise ValueError("input_data can not contain zero dimension.")
         if isinstance(input_data, (tuple, list)):
-            _check_sequence_shape(input_data)
-            if np.array(input_data).ndim >= 1 and np.array(input_data).size == 0:
+            try:
+                np_data = np.array(input_data)
+            except ValueError as e:
+                if "The requested array has an inhomogeneous shape" in str(e):
+                    raise TypeError(f"For Tensor, the input_data is {input_data} that contain unsupported element.")
+                raise
+            if np_data.ndim >= 1 and np_data.size == 0:
                 raise ValueError("input_data can not contain zero dimension.")
 
     if shape is not None and not (hasattr(init, "__enable_zero_dim__") and init.__enable_zero_dim__) and 0 in shape:

mindspore/communication/comm_func.py

@@ -209,7 +209,7 @@ def all_reduce(tensor, op=ReduceOp.SUM, group=GlobalComm.WORLD_COMM_GROUP, async
         RuntimeError: If device target is invalid, or backend is invalid, or distributed initialization fails.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend``
 
     Examples:
         .. note::
@@ -275,7 +275,7 @@ def all_gather_into_tensor(tensor, group=GlobalComm.WORLD_COMM_GROUP, async_op=F
         RuntimeError: If device target is invalid, or backend is invalid, or distributed initialization fails.
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend``
 
     Examples:
         .. note::
@@ -349,7 +349,7 @@ def reduce_scatter_tensor(tensor, op=ReduceOp.SUM, group=GlobalComm.WORLD_COMM_G
         RuntimeError: If device target is invalid, or backend is invalid, or distributed initialization fails.
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend``
 
     Examples:
         .. note::
@@ -909,7 +909,7 @@ def send(tensor, dst=0, group=GlobalComm.WORLD_COMM_GROUP, tag=0):
         ValueError: If the rank ID of the process is greater than the rank size of the communication group.
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend``
 
     Examples:
         .. note::
@@ -970,7 +970,7 @@ def recv(tensor, src=0, group=GlobalComm.WORLD_COMM_GROUP, tag=0):
         ValueError: If the rank ID of the process is greater than the rank size of the communication group.
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend``
 
     Examples:
         .. note::
@@ -1040,7 +1040,7 @@ def isend(tensor, dst=0, group=GlobalComm.WORLD_COMM_GROUP, tag=0):
         ValueError: If the rank ID of the process is greater than the rank size of the communication group.
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend``
 
     Examples:
         .. note::
@@ -1105,7 +1105,7 @@ def irecv(tensor, src=0, group=GlobalComm.WORLD_COMM_GROUP, tag=0):
         ValueError: If the rank ID of the process is greater than the rank size of the communication group.
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend``
 
     Examples:
         .. note::

mindspore/context.py

@@ -1686,6 +1686,15 @@ def set_context(**kwargs):
                 - 3: Optimize dataset reader with all scenes.
               - bias_add_comm_swap (bool): Enable node execution order swap communication operators and add operators
                 if ``True``. Only 1-dimension bias node is supported. Default: ``False``.
+              - enable_allreduce_slice_to_reducescatter (bool): Enable allreduce optimization. In the scenario where
+                the batchmatmul model introduces allreduce in parallel, if the subsequent nodes are stridedslice
+                operator with model parallel, allreduce will be optimized as reducescatter according to the identified
+                patterns. Typical used in MoE module with groupwise alltoall. Default: ``False``.
+              - enable_interleave_split_concat_branch (bool): Enable communication computation parallel optimization
+                for branches formed by split and concat operators with ``enable_interleave`` attribute. It is typical
+                used in MoE parallel scenario. After splitting the input data, each slice of data is processed by the
+                MoE module, and then the branch results are concatenated. When the optimization is enable,
+                communication and computation will be executed in parallel between branches. Default: ``False``.
             - host_scheduling_max_threshold(int): The max threshold to control whether the dynamic shape process is
               used when run the static graph, the default value is 0. When the number of operations in the static graph
               is less than the max threshold, this graph will be executed in dynamic shape process. In large model

mindspore/include/mindapi/base/format.h

@@ -161,5 +161,18 @@ inline std::string FormatEnumToString(mindspore::Format format) {
   }
   return names[format];
 }
+
+inline Format FromStrToEnum(const std::string &format_str) {
+  if (format_str == "DefaultFormat") {
+    return mindspore::Format::DEFAULT_FORMAT;
+  }
+  const auto &names = GetFormatNames();
+  for (size_t i = 0; i < names.size(); ++i) {
+    if (names[i] == format_str) {
+      return static_cast<mindspore::Format>(i);
+    }
+  }
+  return mindspore::Format::DEFAULT_FORMAT;
+}
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_MINDAPI_BASE_FORMAT_H_

mindspore/lib/plugin/ascend/custom_ascendc_ops/op_impl/ai_core/tbe/kernel/config/ascend910b/all_finite.json

@@ -2,16 +2,16 @@
   "binList": [
     {
       "simplifiedKey": [
-        "AllFinite/d=0,p=0/0,2/12,2",
-        "AllFinite/d=1,p=0/0,2/12,2"
+        "AllFinite/d=0,p=0/1,2/12,2",
+        "AllFinite/d=1,p=0/1,2/12,2"
       ],
-      "staticKey": "d0f82552295948866b5bab1c0ef5a9cd9662ee964af71eeea40b0c8d27c08835",
+      "staticKey": "aaee380ee48b9c261d816baac1f6fc0b820ce3b2255e1eff19382df469b7e6de",
       "int64Mode": false,
       "inputs": [
         {
           "name": "gradient",
           "index": 0,
-          "dtype": "float32",
+          "dtype": "float16",
           "format": "ND",
           "paramType": "required",
           "shape": [
@@ -32,21 +32,21 @@
         }
       ],
       "binInfo": {
-        "jsonFilePath": "ascend910b/all_finite/AllFinite_576ceaeef5870c451cab59af55ea46ad.json"
+        "jsonFilePath": "ascend910b/all_finite/AllFinite_f55e0ebaad1f2f572e43677336992fa0.json"
       }
     },
     {
       "simplifiedKey": [
-        "AllFinite/d=0,p=0/1,2/12,2",
-        "AllFinite/d=1,p=0/1,2/12,2"
+        "AllFinite/d=0,p=0/0,2/12,2",
+        "AllFinite/d=1,p=0/0,2/12,2"
       ],
-      "staticKey": "aaee380ee48b9c261d816baac1f6fc0b820ce3b2255e1eff19382df469b7e6de",
+      "staticKey": "d0f82552295948866b5bab1c0ef5a9cd9662ee964af71eeea40b0c8d27c08835",
       "int64Mode": false,
       "inputs": [
         {
           "name": "gradient",
           "index": 0,
-          "dtype": "float16",
+          "dtype": "float32",
           "format": "ND",
           "paramType": "required",
           "shape": [
@@ -67,7 +67,7 @@
         }
       ],
       "binInfo": {
-        "jsonFilePath": "ascend910b/all_finite/AllFinite_f55e0ebaad1f2f572e43677336992fa0.json"
+        "jsonFilePath": "ascend910b/all_finite/AllFinite_576ceaeef5870c451cab59af55ea46ad.json"
       }
     },
     {

mindspore/lib/plugin/ascend/custom_ascendc_ops/op_impl/ai_core/tbe/kernel/config/ascend910b/binary_info_config.json

@@ -5,23 +5,23 @@
     "binaryList": [
       {
         "coreType": 2,
-        "simplifiedKey": "AllFinite/d=0,p=0/0,2/12,2",
-        "binPath": "ascend910b/all_finite/AllFinite_576ceaeef5870c451cab59af55ea46ad.o"
+        "simplifiedKey": "AllFinite/d=0,p=0/1,2/12,2",
+        "binPath": "ascend910b/all_finite/AllFinite_f55e0ebaad1f2f572e43677336992fa0.o"
       },
       {
         "coreType": 2,
-        "simplifiedKey": "AllFinite/d=1,p=0/0,2/12,2",
-        "binPath": "ascend910b/all_finite/AllFinite_576ceaeef5870c451cab59af55ea46ad.o"
+        "simplifiedKey": "AllFinite/d=1,p=0/1,2/12,2",
+        "binPath": "ascend910b/all_finite/AllFinite_f55e0ebaad1f2f572e43677336992fa0.o"
       },
       {
         "coreType": 2,
-        "simplifiedKey": "AllFinite/d=0,p=0/1,2/12,2",
-        "binPath": "ascend910b/all_finite/AllFinite_f55e0ebaad1f2f572e43677336992fa0.o"
+        "simplifiedKey": "AllFinite/d=0,p=0/0,2/12,2",
+        "binPath": "ascend910b/all_finite/AllFinite_576ceaeef5870c451cab59af55ea46ad.o"
       },
       {
         "coreType": 2,
-        "simplifiedKey": "AllFinite/d=1,p=0/1,2/12,2",
-        "binPath": "ascend910b/all_finite/AllFinite_f55e0ebaad1f2f572e43677336992fa0.o"
+        "simplifiedKey": "AllFinite/d=1,p=0/0,2/12,2",
+        "binPath": "ascend910b/all_finite/AllFinite_576ceaeef5870c451cab59af55ea46ad.o"
       },
       {
         "coreType": 2,

mindspore/lib/plugin/ascend/custom_compiler/setup.py

@@ -274,7 +274,7 @@ class CustomOOC():
         else:
             with open('build.log', 'r') as file:
                 for line in file:
-                    logger.debug(line.strip())
+                    logger.error(line.strip())
             raise RuntimeError("Compile failed! Please see build.log in current directory for detail info.")
 
     def compile(self):

mindspore/lib/plugin/ascend/ms_kernels_internal/asdops/include/asdops/utils/rt/base/types.h

@@ -77,16 +77,16 @@ typedef struct {
 } AsdRtModuleInfo;
 
 typedef struct {
-    uint16_t addrOffset{0};
-    uint16_t dataOffset{0};
+    uint32_t addrOffset{0};
+    uint32_t dataOffset{0};
 } RtHostInputInfoT;
 
 typedef struct {
     void *args{nullptr};
     RtHostInputInfoT *hostInputInfoPtr{nullptr};
     uint32_t argsSize{0};
-    uint16_t tilingAddrOffset{0};
-    uint16_t tilingDataOffset{0};
+    uint32_t tilingAddrOffset{0};
+    uint32_t tilingDataOffset{0};
     uint16_t hostInputInfoNum{0};
     uint8_t hasTiling{0};
     uint8_t isNoNeedH2DCopy{0};
@@ -111,4 +111,4 @@ typedef struct {
 #ifdef __cplusplus
 }
 #endif
-#endif
+#endif

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/acme/include/acme_op.h

@@ -34,6 +34,7 @@ class AcmeOp {
   AcmeStatus Init();
 
   virtual AcmeStatus UpdateShape(const ShapeInfoList &inputs_shape, const ShapeInfoList &outputs_shape);
+  virtual AcmeStatus UpdateParam(const void *) { return kAcmeOk; }
 
   size_t GetTilingSize() const;
   virtual std::vector<size_t> GetWorkspaceSize() const;

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/acme/src/ops/host_src/paged_attention_op.h

@@ -51,6 +51,7 @@ class PagedAttentionOp : public MultiImplsOp {
 
   AsdOps::Any BuildAsdParam() override;
   AcmeStatus UpdateShape(const ShapeInfoList &inputs_shape, const ShapeInfoList &outputs_shape) override;
+  AcmeStatus UpdateParam(const void *) override;
   const std::string &TargetKernelName() const override { return target_kernel_name_; }
   ShapeInfoList InferShape(const ShapeInfoList &inputs_shape) const override;
 
@@ -66,7 +67,7 @@ class PagedAttentionOp : public MultiImplsOp {
   uint32_t GetLaunchCoreNumAcme() const override;
   AcmeStatus CreateAsdTensor();
   AcmeStatus UpdateAsdParam();
-  AcmeStatus UpdateAsdTensor(ShapeInfoList *asd_input_shape, ShapeInfoList *asd_output_shape);
+  AcmeStatus UpdateAsdTensor();
   AcmeStatus CheckAsdopSupport() const;
 
  private:
@@ -74,6 +75,10 @@ class PagedAttentionOp : public MultiImplsOp {
   PagedAttentionParam param_;
   InputsDescList asd_inputs_;
   OutputsDescList asd_outputs_;
+  InputsImmutableInfoList asd_inputs_ii_;
+  InputsImmutableInfoList asd_outputs_ii_;
+  ShapeInfoList asd_input_shape_;
+  ShapeInfoList asd_output_shape_;
   uint64_t tiling_key_{0};
   bool is_custom_quant_{false};
   bool has_mask_{false};