mindstudio-probe 1.0.4__py3-none-any.whl → 1.1.1__py3-none-any.whl

msprobe/core/compare/layer_mapping/data_scope_parser.py

@@ -0,0 +1,235 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import re
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import ClassVar, Dict, List, Optional, Tuple
+
+import yaml
+from msprobe.core.common.const import Const
+from msprobe.core.common.file_utils import save_yaml
+from msprobe.core.common.log import logger
+from msprobe.core.common.utils import CompareException, add_time_with_yaml
+from msprobe.core.compare.layer_mapping.postprocess_pass import postprocess_pass
+
+
+@dataclass
+class DumpDataItem:
+    framework: str
+    data_name: Optional[str] = None
+    api_type: Optional[str] = None
+    api_name: Optional[str] = None
+    type_name: Optional[str] = None
+    full_scope: str = ""
+    layer_scope: str = ""
+    stack_scope: str = ""
+    frame_stack_scope: str = ""
+    user_stack_scope: str = ""
+    construct_scope: str = ""
+    scope_direction: Optional[str] = None
+    scope_id: Optional[int] = None
+
+    # 类变量使用 ClassVar
+    framework2layername: ClassVar[Dict[str, str]] = {
+        Const.MS_FRAMEWORK: Const.CELL, Const.PT_FRAMEWORK: Const.MODULE}
+    framework2stack_sign: ClassVar[Dict[str, Tuple[str, str]]] = {
+        Const.MS_FRAMEWORK: ("Template", "construct"),
+        Const.PT_FRAMEWORK: ("Template", r"in (for|back)ward,")
+    }
+
+    @staticmethod
+    def check_stack_valid(stack_info):
+        if stack_info is not None:
+            if not isinstance(stack_info, list):
+                logger.error(f"stack is invalid, it should be a list[str], but got {stack_info}")
+                raise CompareException(CompareException.INVALID_DATA_ERROR)
+            for stack in stack_info:
+                if not isinstance(stack, str):
+                    logger.error(f"stack is invalid, it should be a list[str], but got {stack_info}")
+                    raise CompareException(CompareException.INVALID_DATA_ERROR)
+
+    def set(self, data_name: str, construct_info: str, stack_info: str) -> None:
+        self.set_name(data_name)
+        self.set_layer_scope(construct_info)
+        self.set_stack_scope(stack_info)
+        self.set_full_scope()
+
+    def set_name(self, data_name: str) -> None:
+        self.data_name = data_name
+        data_name_list = data_name.split(Const.SEP)
+        if not data_name_list or len(data_name_list) < abs(Const.LAYER_NAME_INDEX):
+            logger.error(
+                f"The dump data does not comply with the format specification and "
+                f"must contain no less than four fields. "
+                f"The current data is {data_name}"
+            )
+            raise CompareException(CompareException.INVALID_DATA_ERROR)
+
+        self.api_type = data_name_list[Const.API_TYPE_INDEX]
+        self.type_name = data_name_list[Const.TYPE_NAME_INDEX]
+        if self.api_type == self.framework2layername.get(self.framework):
+            self.api_name = data_name_list[Const.LAYER_NAME_INDEX]
+        else:
+            self.api_name = self.type_name
+
+    def set_layer_scope(self, construct_info: str) -> None:
+        self.construct_scope = construct_info
+        if self.api_type == self.framework2layername.get(self.framework):
+            # remove api name
+            data_list = self.data_name.split(Const.SEP)
+            data_list = data_list[:Const.LAYER_NAME_INDEX] + data_list[Const.TYPE_NAME_INDEX:]
+        elif construct_info:
+            data_list = construct_info.split(Const.SEP)
+        else:
+            data_list = []
+
+        if data_list:
+            self.layer_scope = Const.SEP.join(data_list[:Const.TYPE_NAME_INDEX])
+        else:
+            self.layer_scope = self.framework2layername.get(self.framework)
+        if construct_info:
+            construct_list = construct_info.split(Const.SEP)
+            if len(construct_list) < abs(Const.LAYER_NAME_INDEX):
+                logger.error(
+                    f"The construct data does not comply with the format specification and "
+                    f"must contain no less than four fields. "
+                    f"The current data is {construct_info}"
+                )
+                raise CompareException(CompareException.INVALID_DATA_ERROR)
+            self.scope_id = construct_list[Const.SCOPE_ID_INDEX]
+            self.scope_direction = construct_list[Const.SCOPE_DIRECTION_INDEX]
+
+    def set_stack_scope(self, stack_info: str) -> None:
+        # Cell/Module has no stack info
+        if self.api_type == self.framework2layername.get(self.framework):
+            return
+
+        if self.api_type in Const.DATA_TYPE_SKIP_LIST or not stack_info:
+            return
+
+        start_sign, end_sign = self.framework2stack_sign.get(self.framework)
+        self.check_stack_valid(stack_info)
+        start_pos, end_pos = find_regard_scope(stack_info, start_sign, end_sign)
+        # 获取指定范围的代码
+        regard_scope = stack_info[start_pos + 1:end_pos]
+        frame_func_stack_list, user_func_stack_list = find_stack_func_list(regard_scope)
+        self.frame_stack_scope = Const.SEP.join(frame_func_stack_list)
+        self.user_stack_scope = Const.SEP.join(user_func_stack_list)
+
+    def set_full_scope(self, use_user_func_scope=False, use_frame_func_scope=True) -> None:
+        scope_list = [self.layer_scope]
+        if use_user_func_scope and self.user_stack_scope:
+            scope_list.append(self.user_stack_scope)
+        if use_frame_func_scope and self.frame_stack_scope:
+            scope_list.append(self.frame_stack_scope)
+        scope_list.append(self.api_name)
+        self.full_scope = Const.SEP.join(scope_list)
+
+
+def find_regard_scope(lines, start_sign, end_sign):
+    # 找出 start_pos 和 end_pos
+    start_pos = -1
+    end_pos = len(lines)
+    for idx, ii in enumerate(lines):
+        if re.search(start_sign, ii):
+            start_pos = idx
+        elif start_pos >= 0 and re.search(end_sign, ii):
+            end_pos = idx
+            break
+    return start_pos, end_pos
+
+
+def find_stack_func_list(lines, record_user=True):
+    res_list = []
+    user_stack = []
+    frame_stack = None
+    no_entrance = True
+    for line in lines:
+        ele_list = line.split(Const.COMMA)
+        file_ele = ele_list[Const.STACK_FILE_INDEX]
+        # if framework func line and no framework entrance found yet
+        if any(ii in file_ele for ii in Const.FRAME_FILE_LIST) and no_entrance:
+            frame_stack = line  # Update the last target index
+        else:
+            if record_user:
+                user_stack.append(line)
+            no_entrance = False
+
+    # Check if the last string in the list contains target str
+    if frame_stack and no_entrance:
+        no_entrance = False
+
+    # 过滤和处理 regard_scope
+    frame_func = get_stack_in_lines([frame_stack])
+    user_func = get_stack_in_lines(user_stack)
+    return (frame_func, user_func)
+
+
+def get_stack_in_lines(simplified: List[str]):
+    res_list = []
+    if not simplified:
+        return res_list
+    for line in simplified:
+        if not line:
+            continue
+
+        ele_list = line.split(Const.COMMA)
+        file_ele = ele_list[Const.STACK_FILE_INDEX]
+        if any(ii in file_ele for ii in Const.FILE_SKIP_LIST):
+            continue
+
+        func_ele = ele_list[Const.STACK_FUNC_INDEX]
+        if any(ii in func_ele for ii in Const.FUNC_SKIP_LIST):
+            continue
+
+        in_func_name = func_ele.split()[Const.STACK_FUNC_ELE_INDEX]
+
+        res_list.append(in_func_name)
+
+    reversed_list = res_list[::-1]
+    return reversed_list
+
+
+def dumpdata_representer(dumper, data):
+    d = deepcopy(data.__dict__)
+    d.pop("data_name")
+    return dumper.represent_dict(d)
+
+
+def get_dump_data_items(dump, stack, construct, framework, output_path=None):
+    if not stack or not construct:
+        return []
+    name2item = {}
+    data_items = []
+
+    dump_data = dump.get("data", {})
+    for data_name in dump_data:
+        code_info = stack.get(data_name, None)
+        parent_info = construct.get(data_name, None)
+        data_item = DumpDataItem(framework)
+        data_item.set(data_name, parent_info, code_info)
+        name2item[data_name] = data_item
+        data_items.append(data_item)
+
+    postprocess_pass(data_items, name2item)
+
+    if output_path:
+        yaml.add_representer(DumpDataItem, dumpdata_representer)
+        file_name = add_time_with_yaml(f"{framework}_data")
+        file_path = os.path.join(os.path.realpath(output_path), file_name)
+        save_yaml(file_path, name2item)
+    return data_items

msprobe/core/compare/layer_mapping/layer_mapping.py

@@ -0,0 +1,242 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+
+from msprobe.core.common.const import CompareConst, Const
+from msprobe.core.common.file_utils import load_json, load_yaml, save_yaml
+from msprobe.core.common.utils import (add_time_with_yaml,
+                                       detect_framework_by_dump_json,
+                                       get_stack_construct_by_dump_json_path)
+from msprobe.core.compare.layer_mapping.data_scope_parser import get_dump_data_items
+from msprobe.core.compare.utils import read_op
+
+
+class LayerTrie:
+    def __init__(self, type_name, framework=None):
+        self.type_name = type_name
+        self.data_items = []
+        self.children = {}
+        self.framework = framework
+
+    def __repr__(self):
+        return f"Layer(type_name={self.type_name}, data_number={len(self.data_items)})"
+
+    def get(self, name):
+        return self.children.get(name)
+
+    def insert(self, data_item):
+        parts = data_item.full_scope.split(Const.SEP)
+        node = self
+        scope_name_list = parts[Const.RIGHT_MOVE_INDEX:]
+
+        for name in scope_name_list:
+            if name not in node.children:
+                node.children[name] = LayerTrie(name, data_item.framework)
+            node = node.children[name]
+        node.data_items.append(data_item)
+        node.type_name = data_item.type_name
+
+    def query_data(self, scope, index, default_value=None):
+        parts = scope.split(Const.SEP)
+        node = self
+        scope_name_list = parts[1:]
+
+        for name in scope_name_list:
+            if name not in node.children:
+                return default_value
+            node = node.children[name]
+        if index >= len(node.data_items):
+            return default_value
+        return node.data_items[index]
+
+    def save_to_yaml(self, output_path):
+        result = {f"{self.type_name} @ {self}": self.convert_to_dict(self)}
+        file_name = add_time_with_yaml(f"{self.framework}_tree")
+        file_path = os.path.join(os.path.realpath(output_path), file_name)
+        save_yaml(file_path, result)
+
+    def convert_to_dict(self, node):
+        result = {}
+        result["data_item"] = [node.data_name for node in node.data_items]
+        for child_key, child_node in node.children.items():
+            key = f"{child_key} @ {child_node}"
+            result[key] = self.convert_to_dict(child_node)
+        return result
+
+
+def convert_scope(layer_trie, data_item, mapping=None):
+    if not mapping:
+        mapping = {}
+    new_scope = Const.TOP_LAYER
+    scope_list = data_item.full_scope.split(Const.SEP)
+    cur_node = layer_trie
+
+    idx = 0
+    while idx < len(scope_list) - 1:
+        child_name = scope_list[idx + 1]
+        type_name = cur_node.type_name
+        prefix_mapping = mapping.get(type_name, {})
+        mapping_list = prefix_mapping.get(child_name, [])
+        mapping_list.append((child_name, child_name, 1))
+        step = 1
+        for origin, target, level in mapping_list:
+            if Const.SEP.join(scope_list[idx + 1: idx + level + 1]) == origin:
+                new_scope = new_scope + Const.SEP + target
+                step = level
+                break
+        for _ in range(step):
+            child_node = cur_node.get(scope_list[idx + 1])
+            cur_node = child_node
+            idx += 1
+    index = -1
+    for idx, child in enumerate(cur_node.data_items):
+        if data_item.data_name == child.data_name:
+            index = idx
+    return new_scope, index
+
+
+def get_data_items_and_tree(dump_json_path, output_path):
+    framework = detect_framework_by_dump_json(dump_json_path)
+    stack, construct = get_stack_construct_by_dump_json_path(dump_json_path)
+    dump = load_json(dump_json_path)
+    dump_data_items = get_dump_data_items(dump, stack, construct, framework, output_path)
+    root = LayerTrie(Const.TOP_LAYER, framework)
+    for data_item in dump_data_items:
+        root.insert(data_item)
+    if output_path:
+        root.save_to_yaml(output_path)
+    return dump_data_items, root
+
+
+def convert_data_item(npu_tree, bench_tree, npu_data_item, mapping):
+    new_scope, index = convert_scope(npu_tree, npu_data_item, mapping)
+    bench_data_item = bench_tree.query_data(new_scope, index)
+    return bench_data_item
+
+
+def update_keys_in_place(d):
+    """
+    This function is used to compare and maintain compatibility between the old and new versions.
+    In the old version, 'Cell' was used as the top layer name, while the new version uses 'TopLayer'.
+    """
+    cell_value = d.pop(Const.CELL, None)
+
+    if cell_value is not None:
+        d[Const.TOP_LAYER] = cell_value
+
+
+def preprocess_layer_mapping(mapping):
+    """
+    before:
+        {'A': {'a.b.c': 'new_c',
+               'a.demo': 'new_demo',
+               'z': 'new_z',
+               'd.e': 'e'}}
+    after:
+        {'A': {'a': [('a.b.c', 'new_c', 3), ('a.demo', 'new_demo', 2)],
+               'z': [('z', 'new_z', 1)],
+               'd': [('d.e', 'e', 2)]}}
+    """
+    update_keys_in_place(mapping)
+    final_mapping = {}
+
+    for type_name, name_map in mapping.items():
+        final_mapping[type_name] = {}
+
+        for key, value in name_map.items():
+            key_list = key.split('.')
+            prefix = key_list[0]  # 取前缀
+            key_len = len(key_list)
+            if prefix not in final_mapping[type_name]:
+                final_mapping[type_name][prefix] = []
+            final_mapping[type_name][prefix].append((key, value, key_len))
+
+        # 前缀映射列表按规则长度排序
+        for prefix in final_mapping[type_name]:
+            final_mapping[type_name][prefix].sort(key=lambda x: -x[-1])
+
+    return final_mapping
+
+
+def convert_data_items(npu_tree, bench_tree, npu_data_items, mapping):
+    mapping = preprocess_layer_mapping(mapping)
+    api_mapping = {}
+    for npu_data_item in npu_data_items:
+        bench_data_item = convert_data_item(npu_tree, bench_tree, npu_data_item, mapping)
+        bench_name = bench_data_item.data_name if bench_data_item else CompareConst.N_A
+        npu_name = npu_data_item.data_name
+        api_mapping[npu_name] = bench_name
+    return api_mapping
+
+
+def generate_api_mapping_by_layer_mapping(npu_json_path, bench_json_path, layer_mapping_path=None, output_path=None):
+    npu_data_items, npu_root = get_data_items_and_tree(npu_json_path, output_path)
+    _, bench_root = get_data_items_and_tree(bench_json_path, output_path)
+    if isinstance(layer_mapping_path, str):
+        mapping = load_yaml(layer_mapping_path)
+    else:
+        mapping = {}
+    api_mapping = convert_data_items(npu_root, bench_root, npu_data_items, mapping)
+    if output_path:
+        file_name = add_time_with_yaml("api_mapping")
+        file_path = os.path.join(os.path.realpath(output_path), file_name)
+        save_yaml(file_path, api_mapping)
+    return api_mapping
+
+
+def generate_data_mapping(npu_json_path, bench_json_path, api_mapping, output_path=None):
+    def read_full_op_names(data, op_name):
+        op_parsed_list = read_op(data.get(op_name, {}), op_name)
+        full_op_names = [op_parsed.get('full_op_name') for op_parsed in op_parsed_list]
+        return full_op_names
+
+    def generate_op_data_mapping(npu_op_name, npu_full_op_names, bench_op_name, bench_full_op_names):
+        suffix_to_full_op_name = {}
+        op_data_mapping = {}
+        for bench_full_op_name in bench_full_op_names:
+            suffix = bench_full_op_name[len(bench_op_name):]
+            suffix_to_full_op_name[suffix] = bench_full_op_name
+
+        for npu_full_op_name in npu_full_op_names:
+            suffix = npu_full_op_name[len(npu_op_name):]
+            op_data_mapping[npu_full_op_name] = suffix_to_full_op_name.get(suffix, CompareConst.N_A)
+        return op_data_mapping
+
+    npu_data = load_json(npu_json_path).get("data", {})
+    bench_data = load_json(bench_json_path).get("data", {})
+    data_mapping = {}
+    for npu_op_name, bench_op_name in api_mapping.items():
+        if not npu_op_name:
+            continue
+        npu_full_op_names = read_full_op_names(npu_data, npu_op_name)
+        bench_full_op_names = read_full_op_names(bench_data, bench_op_name)
+        mapping = generate_op_data_mapping(npu_op_name, npu_full_op_names, bench_op_name, bench_full_op_names)
+        data_mapping.update(mapping)
+    if output_path:
+        file_name = add_time_with_yaml("data_mapping")
+        file_path = os.path.join(os.path.realpath(output_path), file_name)
+        save_yaml(file_path, data_mapping)
+    return data_mapping
+
+
+def generate_data_mapping_by_layer_mapping(input_param, layer_mapping_path=None, output_path=None):
+    npu_json_path = input_param.get("npu_json_path")
+    bench_json_path = input_param.get("bench_json_path")
+    api_mapping = generate_api_mapping_by_layer_mapping(
+        npu_json_path, bench_json_path, layer_mapping_path)
+    data_mapping = generate_data_mapping(
+        npu_json_path, bench_json_path, api_mapping, output_path)
+    return data_mapping

msprobe/core/compare/layer_mapping/postprocess_pass.py

@@ -0,0 +1,94 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import re
+import math
+
+from msprobe.core.common.const import Const
+
+
+def postprocess_pass(data_items, name2item):
+    backward_pass(data_items, name2item)
+    renumber_index_pass(data_items, "ParallelTransformer", "layers")
+
+
+def backward_pass(data_items, name2item):
+    # 处理反向数据，反向无栈信息，沿用正向数据栈信息
+    for data_item in data_items:
+        data_name_list = data_item.data_name.split(Const.SEP)
+        if not data_name_list:
+            continue
+        if Const.BACKWARD in data_name_list[Const.SCOPE_DIRECTION_INDEX :]:
+            data_name_list[Const.SCOPE_DIRECTION_INDEX :] = [
+                s.replace(Const.BACKWARD, Const.FORWARD) for s in data_name_list[Const.SCOPE_DIRECTION_INDEX :]
+            ]
+            forward_name = Const.SEP.join(data_name_list)
+            forward_item = name2item.get(forward_name, None)
+            if not forward_item:
+                continue
+            data_item.stack_scope = forward_item.stack_scope
+            data_item.full_scope = forward_item.full_scope
+            data_item.layer_scope = forward_item.layer_scope
+
+
+def extract_next_item_last_number(data, prefix, default_result=None):
+    result = default_result
+    match = re.search(rf"^{re.escape(prefix)}\.(\S+?)(?:\.|$)", data)
+    if match:
+        next_item = match.group(1)
+        numbers = re.findall(r"\d+", next_item)
+        if numbers:
+            result = int(numbers[-1])
+    return result
+
+
+def replace_next_item_index(full_scope, prefix, index):
+    if math.isinf(index):
+        return full_scope
+    prefix_pattern = rf"^{re.escape(prefix)}\."
+    result = full_scope
+    match = re.search(rf"{prefix_pattern}(\S+?)(?:\.|$)", full_scope)
+    if match:
+        next_item = match.group(1)
+        pattern = rf"{prefix_pattern}{re.escape(next_item)}"
+        result = re.sub(pattern, f"{prefix}.{index}", full_scope, count=1)
+    return result
+
+
+def renumber_index_pass(data_items, type_name, suffix=None):
+    """
+    该函数为解决并行切分场景中编号不一致的比对问题。例如在MindSpore中ParallelTransformer层的PP切分场景，
+    MindSpore中的layers的成员编号是全局的，而在PyTorch中编号为局部的。
+    为适配此种场景，对指定层的索引进行重新编号，以确保在后续处理阶段序号对齐。
+    """
+    prefix_dict = {}  # 保存类型为type_name的前缀和最小编号的映射
+    for data_item in data_items:
+        if data_item.type_name == type_name:
+            prefix = f"{data_item.full_scope}.{suffix}" if suffix else data_item.layer_scope
+            prefix_dict[prefix] = math.inf
+
+    # 计算前缀对应的最小编号
+    for prefix in prefix_dict:
+        for data_item in data_items:
+            res = extract_next_item_last_number(data_item.full_scope, prefix, math.inf)
+            prefix_dict[prefix] = min(prefix_dict[prefix], res)
+
+    # 重新编号
+    for prefix, min_index in prefix_dict.items():
+        for data_item in data_items:
+            full_scope = data_item.full_scope
+            abs_index = extract_next_item_last_number(data_item.full_scope, prefix, math.inf)
+            rel_index = abs_index - min_index
+            full_scope = replace_next_item_index(full_scope, prefix, rel_index)
+            data_item.full_scope = full_scope

msprobe/core/compare/multiprocessing_compute.py

@@ -1,9 +1,22 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 
 import multiprocessing
 from dataclasses import dataclass
-from functools import partial
-import numpy as np
 import pandas as pd
+from tqdm import tqdm
 from msprobe.core.common.log import logger
 from msprobe.core.common.utils import CompareException
 from msprobe.core.common.const import CompareConst
@@ -29,11 +42,19 @@ def _handle_multi_process(func, input_parma, result_df, lock):
         except OSError as e:
             logger.error("pool terminate failed")
 
+    progress_bar = tqdm(total=len(result_df), desc="API/Module Item Compare Process", unit="row", ncols=100)
+
+    def update_progress(size, progress_lock):
+        with progress_lock:
+            progress_bar.update(size)
+
     for process_idx, df_chunk in enumerate(df_chunks):
         idx = df_chunk_size * process_idx
+        chunk_size = len(df_chunk)
         result = pool.apply_async(func,
                                   args=(idx, op_name_mapping_dict, df_chunk, lock, input_parma),
-                                  error_callback=err_call)
+                                  error_callback=err_call,
+                                  callback=update_progress(chunk_size, lock))
         results.append(result)
     final_results = [r.get() for r in results]
     pool.close()
@@ -42,7 +63,7 @@ def _handle_multi_process(func, input_parma, result_df, lock):
 
 
 def _ms_graph_handle_multi_process(func, result_df, mode):
-    process_num = int((multiprocessing.cpu_count() + 1) // 2)
+    process_num = int((multiprocessing.cpu_count() + 1) // 4)
     df_chunk_size = len(result_df) // process_num
     if df_chunk_size > 0:
         df_chunks = [result_df.iloc[i:i + df_chunk_size] for i in range(0, len(result_df), df_chunk_size)]
@@ -84,7 +105,8 @@ def read_dump_data(result_df):
     except IndexError as e:
         logger.error('result dataframe elements can not be access.')
         raise CompareException(CompareException.INDEX_OUT_OF_BOUNDS_ERROR) from e
-    
+
+
 @dataclass
 class ComparisonResult:
     cos_result: list
@@ -116,9 +138,12 @@ def _save_cmp_result(offset, result: ComparisonResult, result_df, lock):
             result_df.loc[process_index, CompareConst.MAX_ABS_ERR] = result.max_err_result[i]
             result_df.loc[process_index, CompareConst.MAX_RELATIVE_ERR] = result.max_relative_err_result[i]
             result_df.loc[process_index, CompareConst.ERROR_MESSAGE] = result.err_msgs[i]
-            result_df.loc[process_index, CompareConst.ACCURACY] = check_accuracy(result.cos_result[i], result.max_err_result[i])
-            result_df.loc[process_index, CompareConst.ONE_THOUSANDTH_ERR_RATIO] = result.one_thousand_err_ratio_result[i]
-            result_df.loc[process_index, CompareConst.FIVE_THOUSANDTHS_ERR_RATIO] = result.five_thousand_err_ratio_result[i]
+            result_df.loc[process_index, CompareConst.ACCURACY] = (
+                check_accuracy(result.cos_result[i], result.max_err_result[i]))
+            result_df.loc[process_index, CompareConst.ONE_THOUSANDTH_ERR_RATIO] = (
+                result.one_thousand_err_ratio_result)[i]
+            result_df.loc[process_index, CompareConst.FIVE_THOUSANDTHS_ERR_RATIO] = (
+                result.five_thousand_err_ratio_result)[i]
         return result_df
     except ValueError as e:
         logger.error('result dataframe is not found.')