mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/_akg/akg/tvm/exec/measure_peak.py

@@ -1,48 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.
-"""measure bandwidth and compute peak
-
-e.g.
-python3 -m tvm.exec.measure_peak --target cuda --rpc-host 0.0.0.0 --rpc-port 9090
-python3 -m tvm.exec.measure_peak --target opencl --target-host "llvm -target=aarch64-linux-gnu" \
-        --rpc-host $TVM_OPENCL_DEVICE_HOST --rpc-port 9090
-"""
-
-import argparse
-import logging
-
-from ..contrib.peak import measure_peak_all
-
-def main():
-    """Main funciton"""
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--target', type=str, default="llvm",
-                        help='The build target')
-    parser.add_argument('--target-host', type=str, default=None,
-                        help='The host code compilation target')
-    parser.add_argument('--rpc-host', type=str, default="0.0.0.0",
-                        help='the hostname of the server')
-    parser.add_argument('--rpc-port', type=int, default=9090,
-                        help='The port of the RPC')
-
-    args = parser.parse_args()
-    logging.basicConfig(level=logging.INFO)
-
-    measure_peak_all(args.target, args.target_host, args.rpc_host, args.rpc_port)
-
-if __name__ == "__main__":
-    main()

mindspore/_akg/akg/tvm/exec/query_rpc_tracker.py

@@ -1,48 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.
-"""Tool to query RPC tracker status"""
-from __future__ import absolute_import
-
-import logging
-import argparse
-import os
-from .. import rpc
-
-def main():
-    """Main funciton"""
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--host', type=str, default="",
-                        help='the hostname of the tracker')
-    parser.add_argument('--port', type=int, default=None,
-                        help='The port of the RPC')
-    args = parser.parse_args()
-    logging.basicConfig(level=logging.INFO)
-
-    # default to local host or environment variable
-    if not args.host:
-        args.host = os.environ.get("TVM_TRACKER_HOST", "localhost")
-
-    if not args.port:
-        args.port = int(os.environ.get("TVM_TRACKER_PORT", "9190"))
-
-    conn = rpc.connect_tracker(args.host, args.port)
-    # pylint: disable=superfluous-parens
-    print("Tracker address %s:%d\n" % (args.host, args.port))
-    print("%s" % conn.text_summary())
-
-if __name__ == "__main__":
-    main()

mindspore/_akg/akg/tvm/exec/rpc_proxy.py

@@ -1,98 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.
-# pylint: disable=redefined-outer-name, invalid-name
-"""RPC web proxy, allows redirect to websocket based RPC servers(browsers)"""
-from __future__ import absolute_import
-
-import logging
-import argparse
-import multiprocessing
-import sys
-import os
-from ..rpc.proxy import Proxy
-
-
-def find_example_resource():
-    """Find resource examples."""
-    curr_path = os.path.dirname(os.path.realpath(os.path.expanduser(__file__)))
-    base_path = os.path.join(curr_path, "../../../")
-    index_page = os.path.join(base_path, "web/example_rpc.html")
-    js_files = [
-        os.path.join(base_path, "web/tvm_runtime.js"),
-        os.path.join(base_path, "build/libtvm_web_runtime.js"),
-        os.path.join(base_path, "build/libtvm_web_runtime.js.mem")
-    ]
-    for fname in [index_page] + js_files:
-        if not os.path.exists(fname):
-            raise RuntimeError("Cannot find %s" % fname)
-    return index_page, js_files
-
-
-def main(args):
-    """Main funciton"""
-    if args.tracker:
-        url, port = args.tracker.split(":")
-        port = int(port)
-        tracker_addr = (url, port)
-    else:
-        tracker_addr = None
-
-    if args.example_rpc:
-        index, js_files = find_example_resource()
-        prox = Proxy(args.host,
-                     port=args.port,
-                     web_port=args.web_port,
-                     index_page=index,
-                     resource_files=js_files,
-                     tracker_addr=tracker_addr)
-    else:
-        prox = Proxy(args.host,
-                     port=args.port,
-                     web_port=args.web_port,
-                     tracker_addr=tracker_addr)
-    prox.proc.join()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--host', type=str, default="0.0.0.0",
-                        help='the hostname of the server')
-    parser.add_argument('--port', type=int, default=9090,
-                        help='The port of the RPC')
-    parser.add_argument('--web-port', type=int, default=8888,
-                        help='The port of the http/websocket server')
-    parser.add_argument('--example-rpc', type=bool, default=False,
-                        help='Whether to switch on example rpc mode')
-    parser.add_argument('--tracker', type=str, default="",
-                        help="Report to RPC tracker")
-    parser.add_argument('--no-fork', dest='fork', action='store_false',
-                        help="Use spawn mode to avoid fork. This option \
-                         is able to avoid potential fork problems with Metal, OpenCL \
-                         and ROCM compilers.")
-    parser.set_defaults(fork=True)
-    args = parser.parse_args()
-    logging.basicConfig(level=logging.INFO)
-    if args.fork is False:
-        if sys.version_info[0] < 3:
-            raise RuntimeError(
-                "Python3 is required for spawn mode."
-            )
-        multiprocessing.set_start_method('spawn')
-    else:
-        logging.info("If you are running ROCM/Metal, \
-        fork with cause compiler internal error. Try to launch with arg ```--no-fork```")
-    main(args)

mindspore/_akg/akg/tvm/exec/rpc_server.py

@@ -1,88 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.
-# pylint: disable=redefined-outer-name, invalid-name
-"""Start an RPC server"""
-from __future__ import absolute_import
-
-import argparse
-import multiprocessing
-import sys
-import logging
-from .. import rpc
-
-def main(args):
-    """Main function"""
-
-    if args.tracker:
-        url, port = args.tracker.rsplit(":", 1)
-        port = int(port)
-        tracker_addr = (url, port)
-        if not args.key:
-            raise RuntimeError(
-                "Need key to present type of resource when tracker is available")
-    else:
-        tracker_addr = None
-
-    server = rpc.Server(args.host,
-                        args.port,
-                        args.port_end,
-                        key=args.key,
-                        tracker_addr=tracker_addr,
-                        load_library=args.load_library,
-                        custom_addr=args.custom_addr,
-                        silent=args.silent)
-    server.proc.join()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--host', type=str, default="0.0.0.0",
-                        help='the hostname of the server')
-    parser.add_argument('--port', type=int, default=9090,
-                        help='The port of the RPC')
-    parser.add_argument('--port-end', type=int, default=9199,
-                        help='The end search port of the RPC')
-    parser.add_argument('--tracker', type=str,
-                        help="The address of RPC tracker in host:port format. "
-                             "e.g. (10.77.1.234:9190)")
-    parser.add_argument('--key', type=str, default="",
-                        help="The key used to identify the device type in tracker.")
-    parser.add_argument('--silent', action='store_true',
-                        help="Whether run in silent mode.")
-    parser.add_argument('--load-library', type=str,
-                        help="Additional library to load")
-    parser.add_argument('--no-fork', dest='fork', action='store_false',
-                        help="Use spawn mode to avoid fork. This option \
-                         is able to avoid potential fork problems with Metal, OpenCL \
-                         and ROCM compilers.")
-    parser.add_argument('--custom-addr', type=str,
-                        help="Custom IP Address to Report to RPC Tracker")
-
-    parser.set_defaults(fork=True)
-    args = parser.parse_args()
-    logging.basicConfig(level=logging.INFO)
-    if args.fork is False:
-        if sys.version_info[0] < 3:
-            raise RuntimeError(
-                "Python3 is required for spawn mode."
-            )
-        multiprocessing.set_start_method('spawn')
-    else:
-        if not args.silent:
-            logging.info("If you are running ROCM/Metal, fork will cause "
-                         "compiler internal error. Try to launch with arg ```--no-fork```")
-    main(args)

mindspore/_akg/akg/tvm/exec/rpc_tracker.py

@@ -1,62 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.
-# pylint: disable=redefined-outer-name, invalid-name
-"""Tool to start RPC tracker"""
-from __future__ import absolute_import
-
-import logging
-import argparse
-import multiprocessing
-import sys
-from ..rpc.tracker import Tracker
-
-def main(args):
-    """Main funciton"""
-    tracker = Tracker(args.host, port=args.port, port_end=args.port_end,
-                      silent=args.silent)
-    tracker.proc.join()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--host', type=str, default="0.0.0.0",
-                        help='the hostname of the tracker')
-    parser.add_argument('--port', type=int, default=9190,
-                        help='The port of the RPC')
-    parser.add_argument('--port-end', type=int, default=9199,
-                        help='The end search port of the RPC')
-    parser.add_argument('--no-fork', dest='fork', action='store_false',
-                        help="Use spawn mode to avoid fork. This option \
-                         is able to avoid potential fork problems with Metal, OpenCL \
-                         and ROCM compilers.")
-    parser.add_argument('--silent', action='store_true',
-                        help="Whether run in silent mode.")
-
-    parser.set_defaults(fork=True)
-    args = parser.parse_args()
-    logging.basicConfig(level=logging.INFO)
-    if args.fork is False:
-        if sys.version_info[0] < 3:
-            raise RuntimeError(
-                "Python3 is required for spawn mode."
-            )
-        multiprocessing.set_start_method('spawn')
-    else:
-        if not args.silent:
-            logging.info("If you are running ROCM/Metal, fork will cause "
-                         "compiler internal error. Try to launch with arg ```--no-fork```")
-    main(args)

mindspore/_akg/akg/tvm/rpc/__init__.py

@@ -1,29 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.
-"""Lightweight TVM RPC module.
-
-RPC enables connect to a remote server, upload and launch functions.
-This is useful to for cross-compile and remote testing,
-The compiler stack runs on local server, while we use RPC server
-to run on remote runtime which don't have a compiler available.
-
-The test program compiles the program on local server,
-upload and run remote RPC server, get the result back to verify correctness.
-"""
-
-from .server import Server
-from .client import RPCSession, LocalSession, TrackerSession, connect, connect_tracker

mindspore/_akg/akg/tvm/rpc/base.py

@@ -1,182 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.
-"""Base definitions for RPC."""
-# pylint: disable=invalid-name
-
-from __future__ import absolute_import
-
-import socket
-import time
-import json
-import errno
-import struct
-import random
-import logging
-
-from .._ffi.function import _init_api
-from .._ffi.base import py_str
-
-# Magic header for RPC data plane
-RPC_MAGIC = 0xff271
-# magic header for RPC tracker(control plane)
-RPC_TRACKER_MAGIC = 0x2f271
-# sucess response
-RPC_CODE_SUCCESS = RPC_MAGIC + 0
-# duplicate key in proxy
-RPC_CODE_DUPLICATE = RPC_MAGIC + 1
-# cannot found matched key in server
-RPC_CODE_MISMATCH = RPC_MAGIC + 2
-
-logger = logging.getLogger('RPCServer')
-
-class TrackerCode(object):
-    """Enumeration code for the RPC tracker"""
-    FAIL = -1
-    SUCCESS = 0
-    PING = 1
-    STOP = 2
-    PUT = 3
-    REQUEST = 4
-    UPDATE_INFO = 5
-    SUMMARY = 6
-    GET_PENDING_MATCHKEYS = 7
-
-RPC_SESS_MASK = 128
-
-
-def get_addr_family(addr):
-    res = socket.getaddrinfo(addr[0], addr[1], 0, 0, socket.IPPROTO_TCP)
-    return res[0][0]
-
-
-def recvall(sock, nbytes):
-    """Receive all nbytes from socket.
-
-    Parameters
-    ----------
-    sock: Socket
-       The socket
-
-    nbytes : int
-       Number of bytes to be received.
-    """
-    res = []
-    nread = 0
-    while nread < nbytes:
-        chunk = sock.recv(min(nbytes - nread, 1024))
-        if not chunk:
-            raise IOError("connection reset")
-        nread += len(chunk)
-        res.append(chunk)
-    return b"".join(res)
-
-
-def sendjson(sock, data):
-    """send a python value to remote via json
-
-    Parameters
-    ----------
-    sock : Socket
-        The socket
-
-    data : object
-        Python value to be sent.
-    """
-    data = json.dumps(data)
-    sock.sendall(struct.pack("<i", len(data)))
-    sock.sendall(data.encode("utf-8"))
-
-
-def recvjson(sock):
-    """receive python value from remote via json
-
-    Parameters
-    ----------
-    sock : Socket
-        The socket
-
-    Returns
-    -------
-    value : object
-        The value received.
-    """
-    size = struct.unpack("<i", recvall(sock, 4))[0]
-    data = json.loads(py_str(recvall(sock, size)))
-    return data
-
-
-def random_key(prefix, cmap=None):
-    """Generate a random key
-
-    Parameters
-    ----------
-    prefix : str
-        The string prefix
-
-    cmap : dict
-        Conflict map
-
-    Returns
-    -------
-    key : str
-        The generated random key
-    """
-    if cmap:
-        while True:
-            key = prefix + str(random.random())
-            if key not in cmap:
-                return key
-    else:
-        return prefix + str(random.random())
-
-
-def connect_with_retry(addr, timeout=60, retry_period=5):
-    """Connect to a TPC address with retry
-
-    This function is only reliable to short period of server restart.
-
-    Parameters
-    ----------
-    addr : tuple
-        address tuple
-
-    timeout : float
-         Timeout during retry
-
-    retry_period : float
-         Number of seconds before we retry again.
-    """
-    tstart = time.time()
-    while True:
-        try:
-            sock = socket.socket(get_addr_family(addr), socket.SOCK_STREAM)
-            sock.connect(addr)
-            return sock
-        except socket.error as sock_err:
-            if sock_err.args[0] not in (errno.ECONNREFUSED,):
-                raise sock_err
-            period = time.time() - tstart
-            if period > timeout:
-                raise RuntimeError(
-                    "Failed to connect to server %s" % str(addr))
-            logger.warning("Cannot connect to tracker %s, retry in %g secs...",
-                           str(addr), retry_period)
-            time.sleep(retry_period)
-
-
-# Still use tvm.rpc for the foreign functions
-_init_api("tvm.rpc", "tvm.rpc.base")