mindstudio-probe 8.3.0__py3-none-any.whl → 8.3.2__py3-none-any.whl

msprobe/pytorch/api_accuracy_checker/tensor_transport_layer/dump_dispatch.py

@@ -1,115 +0,0 @@
-
-# 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 collections import defaultdict
-from functools import wraps
-
-import torch
-from torch.utils._python_dispatch import TorchDispatchMode
-from msprobe.pytorch.api_accuracy_checker.common.utils import ApiData
-from msprobe.pytorch.common.utils import get_tensor_rank
-from msprobe.core.common.const import Const
-from msprobe.pytorch.common.log import logger
-from msprobe.core.common.file_utils import load_yaml
-
-
-def singleton(cls):
-    _instance = {}
-
-    @wraps(cls)
-    def inner():
-        if cls not in _instance:
-            _instance[cls] = cls()
-        return _instance[cls]
-    return inner
-
-
-@singleton
-class Counter:
-    def __init__(self) -> None:
-        self.index_dict = defaultdict(int)
-
-
-counter = Counter()
-yaml_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "torch_ops_config.yaml")
-yaml_file = load_yaml(yaml_path)
-
-
-class AccuracyCheckerDispatch(TorchDispatchMode):
-    def __init__(self, attl):
-        super(AccuracyCheckerDispatch, self).__init__()
-        self.attl = attl
-        self.counter = counter
-        self.aten_ops_blacklist = []
-        self.npu_adjust_autogard = []
-        self.aten_ops_blacklist = yaml_file.get('aten_ops_blacklist', [])
-        self.npu_adjust_autogard = yaml_file.get('npu_adjust_autogard', [])
-
-    def __torch_dispatch__(self, func, types, args=None, kwargs=None):
-        func_name_split_list = func.__name__.split(Const.SEP)
-        aten_api = func_name_split_list[0]
-        self.enable_autogard(aten_api)
-        if aten_api in self.aten_ops_blacklist:
-            npu_out = func(*args, **kwargs)
-            return npu_out
-
-        res = func(*args, **kwargs)
-        cur_rank = get_tensor_rank(args, res)
-        cur_api_number = self.counter.index_dict[aten_api]
-        api_name = f'{Const.ATEN}{Const.SEP}{aten_api}{Const.SEP}{cur_api_number}'
-        logger.info(f"tools is dumping api: {api_name}, rank: {cur_rank}")
-        api_data = ApiData(api_name, args, kwargs, res, 0, cur_rank)
-        if "device" in api_data.kwargs:
-            api_data.kwargs.pop("device")
-        if self.attl.nfs_path:
-            self.attl.upload(api_data)
-        else:
-            self.attl.send(api_data)
-        self.counter.index_dict[aten_api] += 1
-
-        return res
-    
-    def enable_autogard(self, aten_api):
-        if aten_api in self.npu_adjust_autogard:
-            torch._C._dispatch_tls_set_dispatch_key_excluded(torch._C.DispatchKey.AutogradFunctionality, False)
-
-
-def dispatch4data(func, attl, status):
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        if not status:
-            return func(*args, **kwargs)
-        with AccuracyCheckerDispatch(attl):
-            res = func(*args, **kwargs)
-            return res
-
-    return wrapper
-
-
-def run_ut_dispatch(attl, status, is_recompute=False):
-    """
-    This function called by online_run_ut.
-    It is used to enable or disable dispatch for torch.autograd.backward function.
-
-    Args:
-        attl (ATTL):  online_run_ut class ATTL, which is used to upload or send api data to server.
-        status (bool): True means enable dispatch, False means disable dispatch.
-        is_recompute (bool): Flag of recompute, which is conflicted with aten api, then skip dispatch4data.
-    """
-    if is_recompute:
-        return
-    torch.autograd.backward = dispatch4data(torch.autograd.backward, attl, status)

msprobe/pytorch/api_accuracy_checker/tensor_transport_layer/server.py

@@ -1,250 +0,0 @@
-# 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.
-from functools import partial
-import os
-import struct
-import zlib
-import time
-import io
-from threading import Thread
-
-from twisted.internet import reactor, protocol, endpoints, ssl
-
-from msprobe.pytorch.common.utils import logger
-from msprobe.pytorch.api_accuracy_checker.tensor_transport_layer.utils import cipher_list, \
-    STRUCT_UNPACK_MODE as unpack_mode, STR_TO_BYTES_ORDER as bytes_order, verify_callback, load_ssl_pem
-
-
-class TCPServer:
-    def __init__(self, port, shared_queue, check_sum=False, tls_path=None) -> None:
-        self.port = port
-        self.shared_queue = shared_queue
-        self.check_sum = check_sum
-        self.tls_path = tls_path
-        self.factory = MessageServerFactory()
-        self.reactor_thread = None
-
-    @staticmethod
-    def run_reactor():
-        reactor.run(installSignalHandlers=False)
-
-    def start(self):
-        self.factory.protocol = self.build_protocol
-
-        if self.tls_path:
-            server_key, server_crt, ca_crt, crl_pem = load_ssl_pem(
-                key_file=os.path.join(self.tls_path, "server.key"),
-                cert_file=os.path.join(self.tls_path, "server.crt"),
-                ca_file=os.path.join(self.tls_path, "ca.crt"),
-                crl_file=os.path.join(self.tls_path, "crl.pem")
-            )
-
-            ssl_options = ssl.CertificateOptions(
-                privateKey=server_key,
-                certificate=server_crt,
-                method=ssl.SSL.TLSv1_2_METHOD,
-                verify=True,
-                requireCertificate=True,
-                caCerts=[ca_crt],  # 信任的CA证书列表
-            )
-            ssl_context = ssl_options.getContext()
-            ssl_context.set_cipher_list(cipher_list)
-            ssl_context.set_options(ssl.SSL.OP_NO_RENEGOTIATION)
-            ssl_context.set_verify(ssl.SSL.VERIFY_PEER | ssl.SSL.VERIFY_FAIL_IF_NO_PEER_CERT,
-                                   partial(verify_callback, crl=crl_pem))
-
-            endpoint = endpoints.SSL4ServerEndpoint(reactor, self.port, ssl_options)
-        else:
-            endpoint = endpoints.TCP4ServerEndpoint(reactor, self.port)
-        endpoint.listen(self.factory)
-        self.reactor_thread = Thread(target=self.run_reactor, daemon=True)
-        self.reactor_thread.start()
-
-    def is_running(self):
-        return not self.factory.is_all_connection_closed()
-
-    def stop(self):
-        self.factory.doStop()
-        reactor.callFromThread(reactor.sigInt, 2)
-        self.reactor_thread.join()
-
-    def build_protocol(self):
-        return ServerProtocol(self.shared_queue, self.check_sum)
-
-
-class ServerProtocol(protocol.Protocol):
-    ACK_SUCCESS = b"OK___"
-    ACK_ERROR = b"ERROR"
-    ACK_BUSY = b"BUSY_"
-    ACK_STOP = b"STOP_"
-    ACK_STOP_CONFIRM = b"OVER_"
-    ACK_KILL_PROCESS = b"KILL_"
-
-    def __init__(self, shared_queue, check_sum=False):
-        self.start_time = None
-        self.buffer = io.BytesIO()
-        self.consumer_queue = shared_queue
-        self.check_sum = check_sum
-        self.length_width = 8
-        self.crc_width = 8
-        self.obj_length = None
-        self.tell = 0
-        self.obj_crc = None
-        self.obj_body = None
-        self.sequence_number = -1
-        self.rank = -1
-        self.step = -1
-        self.sequence_number_dict = dict()
-
-    def connectionMade(self):
-        self.buffer = io.BytesIO()
-        self.obj_length = None
-        self.tell = 0
-        self.obj_crc = None
-        self.obj_body = None
-        self.factory.transport_dict[self.transport] = 1
-        self.factory.transport_list.append(self.transport)
-        logger.info(f"Connected to {self.transport.getPeer()} successfully.")
-
-    def connectionLost(self, reason):
-        self.factory.transport_dict.pop(self.transport, None)
-        if len(self.factory.transport_dict) == 0:
-            self.consumer_queue.put(self.ACK_KILL_PROCESS)
-
-        logger.info(f"Lost connection with {self.transport.getPeer()}. Reason is: {reason} 与客户端 断开连接, "
-                    f"current connection number is: {len(self.factory.transport_dict)}")
-
-    def send_ack(self, ack_info):
-        ack_message = b"".join([
-            ack_info,
-            self.sequence_number.to_bytes(8, byteorder=bytes_order),
-            self.rank.to_bytes(8, byteorder=bytes_order),
-            self.step.to_bytes(8, byteorder=bytes_order)
-        ])
-        self.transport.write(ack_message)
-
-    def post_process(self):
-        send_busy_ack = False
-        while self.consumer_queue.full():
-            if not send_busy_ack:
-                self.send_ack(self.ACK_BUSY)
-                logger.debug("sending BUSY ACK")
-            send_busy_ack = True
-            time.sleep(0.1)
-
-        obj_key = str(self.sequence_number) + "_" + str(self.rank) + "_" + str(self.step)
-        # get the crc value of a 16-bit string with a length of 8
-        recv_crc = f"{zlib.crc32(self.obj_body):08x}"
-
-        if self.check_sum and recv_crc != self.obj_crc:
-            # when needs check hash value and check no pass, indicates received data error, send b"ERROR" to client.
-            logger.debug(f"Error:接收数据有问题，流水号{self.sequence_number}, expected {self.obj_crc}, but get {recv_crc}")
-            self.send_ack(self.ACK_ERROR)
-        else:
-            if self.obj_body == self.ACK_STOP:
-                self.handle_with_stop()
-            else:
-                self.send_ack(self.ACK_SUCCESS)
-            if obj_key in self.sequence_number_dict:
-                logger.debug(f"这是一次异常的重传，可以忽略。 {obj_key}, {self.sequence_number_dict}")
-            else:
-                self.sequence_number_dict[obj_key] = self.obj_crc
-                self.consumer_queue.put(self.obj_body, block=True)
-
-        self.reset_env()
-        finish_time = time.time()
-        logger.debug(f"finish_time: {finish_time - self.start_time}")
-
-    def handle_with_stop(self):
-        logger.debug(f"接收到停止传输信号 TCP{self.transport.getPeer()}")
-        self.send_ack(self.ACK_STOP_CONFIRM)
-        if len(self.factory.transport_dict) == 0:
-            _rank, _step, _sequence_number = 0, 0, 100000000
-            ack_kill = self.ACK_KILL_PROCESS + \
-                       _sequence_number.to_bytes(8, byteorder='big') + \
-                       _rank.to_bytes(8, byteorder='big') + \
-                       _step.to_bytes(8, byteorder='big')
-            for trans in self.factory.transport_list:
-                trans.write(ack_kill)
-            logger.debug(f"发送KILL信息给{self.transport.getPeer()}")
-            self.consumer_queue.put(self.ACK_KILL_PROCESS)
-            time.sleep(2)
-
-    def reset_env(self):
-        self.obj_length = None
-        self.sequence_number = -1
-        self.rank = -1
-        self.step = -1
-        self.obj_crc = None
-        self.obj_body = None
-
-    def dataReceived(self, data):
-        self.buffer.seek(0, 2)
-        self.buffer.write(data)
-        self.buffer.seek(self.tell)
-
-        # The first data packet is packet header, it contains obj_length, sequence_number, rank, step
-        if self.obj_length is None and len(self.buffer.getvalue()) >= self.length_width * 4:
-            self.start_time = time.time()
-            self.obj_length = struct.unpack(unpack_mode, self.buffer.read(self.length_width))[0]
-            self.sequence_number = struct.unpack(unpack_mode, self.buffer.read(self.length_width))[0]
-            self.rank = struct.unpack(unpack_mode, self.buffer.read(self.length_width))[0]
-            self.step = struct.unpack(unpack_mode, self.buffer.read(self.length_width))[0]
-            self.tell += self.length_width * 4
-            logger.debug(
-                f"流水号: {self.sequence_number}; RANK: {self.rank}; STEP: {self.step}; Length: {self.obj_length}")
-
-        # If needs check hash but not parse crc yet, read 8b crc values
-        check_sum_and_crc = (self.check_sum
-                             and self.obj_length is not None
-                             and self.obj_crc is None
-                             and len(self.buffer.getvalue()) - self.tell >= self.crc_width)
-        if check_sum_and_crc:
-            self.obj_crc = self.buffer.read(self.crc_width).decode()
-            self.tell += self.crc_width
-            logger.debug(f"Hash value: {self.obj_crc}")
-
-        current_length = len(self.buffer.getvalue()) - self.tell
-        if self.obj_length is not None and 0 < self.obj_length <= current_length:
-            # Current api data receive finished
-            self.obj_body = self.buffer.read(self.obj_length)
-
-            self.tell += self.obj_length
-            self.buffer = io.BytesIO(self.buffer.getvalue()[self.tell:])
-            self.buffer.seek(0)
-            self.tell = 0
-            recv_data_time = time.time()
-            logger.debug(f"self.sequence_number {self.sequence_number} "
-                         f"recv_data_time {recv_data_time - self.start_time}")
-
-            if self.obj_body == self.ACK_STOP:
-                # Indicates the current TCP link receives a STOP signal and remove from the transport_dict
-                _transport = self.factory.transport_dict.pop(self.transport, None)
-                logger.debug(f"接收到b'STOP_' self.sequence_number {self.sequence_number} ")
-            self.post_process()
-
-
-class MessageServerFactory(protocol.ServerFactory):
-    def __init__(self) -> None:
-        """
-        transport_dict: links that have not completed data transmission.
-        transport_list: Records all TCP links. Appends TCP link to the transport list
-                        when a new TCP link is established.
-        """
-        self.transport_dict = {}
-        self.transport_list = []
-
-    def is_all_connection_closed(self):
-        return len(self.transport_dict) == 0

msprobe/pytorch/api_accuracy_checker/tensor_transport_layer/torch_ops_config.yaml

@@ -1,63 +0,0 @@
-aten_ops_blacklist:
-  - npu_binary_cross_entropy_with_logits_backward
-  - npu_ciou_backward
-  - _cudnn_rnn
-  - _local_scalar_dense
-  - _pin_memory
-  - _to_copy
-  - _unsafe_view
-  - clone
-  - contiguous
-  - copy_
-  - cudnn_batch_norm
-  - cudnn_batch_norm_backward
-  - detach
-  - empty
-  - index_put_
-  - lift_fresh
-  - max_pool2d_with_indices_backward # shape unmatch
-  - native_batch_norm_backward
-  - new_empty
-  - new_empty_strided
-  - new_full
-  - new_ones
-  - new_zeros
-  - ones
-  - ones_like
-  - permute
-  - rand
-  - rand_like
-  - randint
-  - randint_like
-  - randn
-  - randn_like
-  - randperm
-  - scalar_tensor
-  - select
-  - to
-  - transpose
-  - unbind
-  - view
-  - zero
-  - zero_
-  - zeros
-  - zeros_like
-  - _record_function_enter_new
-  - _record_function_exit
-  - broadcast_
-  - allreduce_
-  - npu_clear_float_status
-  - npu_format_cast
-  - npu_dtype_cast
-  - npu_dtype_cast_backward
-  - _allgather_base_
-  - _reduce_scatter_base_
-  - is_same_size
-
-npu_adjust_autogard:
-  - adaptive_avg_pool2d
-  - batch_norm
-  - log_softmax
-  - nll_loss
-  - to
-  

msprobe/pytorch/api_accuracy_checker/tensor_transport_layer/utils.py

@@ -1,198 +0,0 @@
-# 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 gc
-import os
-from datetime import datetime, timezone
-
-from OpenSSL import crypto
-from cryptography import x509
-from cryptography.hazmat.backends import default_backend
-from dateutil import parser
-
-from msprobe.core.common.file_utils import FileOpen
-from msprobe.core.common.log import logger
-
-cipher_list = ":".join(
-    ["TLS_DHE_RSA_WITH_AES_128_GCM_SHA256",
-     "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384",
-     "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256",
-     "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384",
-     "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256",
-     "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384",
-     "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256",
-     "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
-     "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
-     "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
-     "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
-     "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256",
-     "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256",
-     "TLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256",
-     "TLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384",
-     "TLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256",
-     "TLS_DHE_RSA_WITH_AES_128_CCM",
-     "TLS_DHE_RSA_WITH_AES_256_CCM",
-     "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256",
-     "TLS_DHE_PSK_WITH_AES_128_CCM",
-     "TLS_DHE_PSK_WITH_AES_256_CCM",
-     "TLS_ECDHE_ECDSA_WITH_AES_128_CCM",
-     "TLS_ECDHE_ECDSA_WITH_AES_256_CCM",
-     "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"]
-).encode()
-
-STRUCT_UNPACK_MODE = "!Q"
-STR_TO_BYTES_ORDER = "big"
-
-
-def is_certificate_revoked(cert, crl):
-    # 获取证书的序列号
-    cert_serial_number = cert.get_serial_number()
-
-    # 检查证书是否在CRL中
-    revoked_serials = [revoked_cert.serial_number for revoked_cert in crl]
-    if cert_serial_number in revoked_serials:
-        logger.error(f"证书已吊销:{cert_serial_number:020x}")
-        return True
-
-    return False
-
-
-def verify_callback(conn, cert, errno, depth, preverify_ok, crl=None):
-    """
-    验证对端证书的有效性
-    :param conn: OpenSSL.SSL.Connection, SSL 连接对象
-    :param cert: OpenSSL.crypto.X509, 当前证书
-    :param errno: int, OpenSSL错误代码, 0:无错误 | 9:证书过期 | 18: 自签名证书
-    :param depth: int, 当前证书在证书链中的深度 (0=叶子节点), 1:中间CA证书 -1:根CA证书 2+:更高级别CA证书
-    :param preverify_ok: int, 验证结果 (1=通过， 0=失败)
-    :param crl: _CRLInternal, CRL证书对象
-    :return: bool, True表示接受证书, False表示拒绝
-    """
-
-    if not preverify_ok:
-        from OpenSSL import SSL
-        error_str = SSL._ffi.string(SSL._lib.X509_verify_cert_error_string(errno)).decode()
-        logger.error(f"证书验证失败 (depth={depth}, err={errno}): {error_str}")
-        return False
-
-    if crl and is_certificate_revoked(cert, crl):
-        return False
-
-    return preverify_ok
-
-
-def load_ssl_pem(key_file, cert_file, ca_file, crl_file):
-    """
-    Load SSL PEM files.
-
-    Args:
-        key_file (str): The path to the private key file.
-        cert_file (str): The path to the certificate file.
-        ca_file (str): The path to the CA certificate file.
-        crl_file (str): The path to the CRL file.
-
-    Returns:
-        tuple: (key, crt, ca_crt, crl)
-
-    Raises:
-        Exception: If the file paths are invalid or the file contents are incorrect, exceptions may be thrown.
-    """
-
-    try:
-        # your_private_key_password
-        import pwinput
-        passphrase = pwinput.pwinput("Enter your password: ")
-        with FileOpen(key_file, "rb") as f:
-            key = crypto.load_privatekey(crypto.FILETYPE_PEM, f.read(), passphrase.encode())
-            del passphrase
-            gc.collect()
-        with FileOpen(cert_file, "rb") as f:
-            crt = crypto.load_certificate(crypto.FILETYPE_PEM, f.read())
-            check_crt_valid(crt)
-
-            crt_serial_number = hex(crt.get_serial_number())[2:]
-            logger.info(f"crt_serial_number: {crt_serial_number}")
-
-        check_certificate_match(crt, key)
-
-        with FileOpen(ca_file, "rb") as f:
-            ca_crt = crypto.load_certificate(crypto.FILETYPE_PEM, f.read())
-            check_crt_valid(ca_crt)
-
-            ca_serial_number = hex(ca_crt.get_serial_number())[2:]
-            logger.info(f"ca_serial_number: {ca_serial_number}")
-        crl = None
-        if os.path.exists(crl_file):
-            with FileOpen(crl_file, "rb") as f:
-                crl = x509.load_pem_x509_crl(f.read(), default_backend())
-                check_crl_valid(crl, ca_crt)
-            for revoked_cert in crl:
-                logger.info(f"Serial Number: {revoked_cert.serial_number}, "
-                            f"Revocation Date: {revoked_cert.revocation_date_utc}")
-
-    except Exception as e:
-        raise RuntimeError(f"The SSL certificate is invalid") from e
-
-    return key, crt, ca_crt, crl
-
-
-def check_crt_valid(pem):
-    """
-    Check the validity of the SSL certificate.
-
-    Raises:
-    RuntimeError: If the SSL certificate is invalid or expired.
-    """
-    try:
-        pem_start = parser.parse(pem.get_notBefore().decode("UTF-8"))
-        pem_end = parser.parse(pem.get_notAfter().decode("UTF-8"))
-        logger.info(f"The SSL certificate passes the verification and the validity period "
-                    f"starts from {pem_start} ends at {pem_end}.")
-    except Exception as e:
-        raise RuntimeError(f"The SSL certificate is invalid") from e
-
-    now_utc = datetime.now(tz=timezone.utc)
-    if pem.has_expired() or not (pem_start <= now_utc <= pem_end):
-        raise RuntimeError(f"The SSL certificate has expired.")
-
-
-def check_certificate_match(certificate, private_key):
-    """
-    Check certificate and private_key is match or not. if mismatched, an exception is thrown.
-    :param certificate:
-    :param private_key:
-    :return:
-    """
-    test_data = os.urandom(256)
-    try:
-        signature = crypto.sign(private_key, test_data, "sha256")
-        crypto.verify(
-            certificate,  # 包含公钥的证书
-            signature,  # 生成的签名
-            test_data,  # 原始数据
-            "sha256",  # 哈希算法
-        )
-        logger.info("公钥和私钥匹配")
-    except Exception as e:
-        raise RuntimeError("公钥和私钥不匹配") from e
-
-
-def check_crl_valid(crl, ca_crt):
-    # 验证CRL签名（确保CRL未被篡改）
-    if not crl.is_signature_valid(ca_crt.get_pubkey().to_cryptography_key()):
-        raise RuntimeError("CRL签名无效！")
-
-    # 检查CRL有效期
-    if not (crl.last_update <= datetime.utcnow() <= crl.next_update):
-        raise RuntimeError("CRL已过期或尚未生效!")

msprobe/pytorch/attl_manager.py

@@ -1,65 +0,0 @@
-# Copyright (c) 2025, 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.runtime import Runtime
-from msprobe.core.common.utils import Const
-from msprobe.pytorch.api_accuracy_checker.common.utils import ApiData
-from msprobe.pytorch.common.log import logger
-
-
-class ATTLManager:
-    def __init__(self, config):
-        self.config = config
-        self.attl = None
-
-    def attl_init(self):
-        if self.config.online_run_ut:
-            from msprobe.pytorch.api_accuracy_checker.tensor_transport_layer.attl import ATTLConfig, ATTL
-            attl_config = ATTLConfig(is_benchmark_device=False,
-                                     connect_ip=self.config.host,
-                                     connect_port=self.config.port,
-                                     nfs_path=self.config.nfs_path,
-                                     tls_path=self.config.tls_path)
-            need_dump = len(self.config.rank) == 0 or Runtime.current_rank in self.config.rank
-            self.attl = ATTL('npu', attl_config, need_dump=need_dump)
-            if self.config.nfs_path:
-                self.attl.upload("start")
-
-    def attl_send(self, name, args, kwargs, output):
-        api_data = ApiData(
-                    name[:-len(Const.FORWARD_NAME_SUFFIX)],
-                    args,
-                    kwargs,
-                    output,
-                    Runtime.current_iter,
-                    Runtime.current_rank
-                )
-        logger.info(f"tools is dumping api: {api_data.name}, rank: {Runtime.current_rank}")
-        api_type, _, _ = api_data.name.split(Const.SEP)
-        if api_type in [Const.DISTRIBUTED]:
-            logger.info(f"api {api_data.name} is not supported, skip")
-            return
-        if self.config.nfs_path:
-            self.attl.upload(api_data)
-        else:
-            self.attl.send(api_data)
-
-    def attl_stop(self):
-        if self.config.nfs_path:
-            self.attl.upload("end")
-        elif self.attl.socket_manager is not None:
-            logger.info(f"pid: {os.getpid()} finished, start sends STOP signal.")
-            self.attl.socket_manager.send_stop_signal()