def test_rpc_remote_module(): if not tvm.module.enabled("rpc"): return server = rpc.Server("localhost") remote = rpc.connect(server.host, server.port) # graph n = tvm.convert(1024) A = tvm.placeholder((n, ), name='A') B = tvm.compute(A.shape, lambda *i: A(*i) + 1.0, name='B') s = tvm.create_schedule(B.op) def check_remote(): if not tvm.module.enabled("llvm"): print("Skip because llvm is not enabled") return temp = util.tempdir() ctx = remote.cpu(0) f = tvm.build(s, [A, B], "llvm", name="myadd") path_dso = temp.relpath("dev_lib.so") f.export_library(path_dso) remote.upload(path_dso) f1 = remote.load_module("dev_lib.so") a = tvm.nd.array(np.random.uniform(size=1024).astype(A.dtype), ctx) b = tvm.nd.array(np.zeros(1024, dtype=A.dtype), ctx) time_f = f1.time_evaluator(f1.entry_name, remote.cpu(0), number=10) cost = time_f(a, b).mean print('%g secs/op' % cost) np.testing.assert_equal(b.asnumpy(), a.asnumpy() + 1) check_remote()
def test_rpc_simple(): if not tvm.module.enabled("rpc"): return @tvm.register_func("rpc.test.addone") def addone(x): return x + 1 @tvm.register_func("rpc.test.strcat") def strcat(name, x): return "%s:%d" % (name, x) @tvm.register_func("rpc.test.except") def remotethrow(name): raise ValueError("%s" % name) server = rpc.Server("localhost") client = rpc.connect(server.host, server.port, key="x1") f1 = client.get_function("rpc.test.addone") assert f1(10) == 11 f3 = client.get_function("rpc.test.except") try: f3("abc") assert False except tvm.TVMError as e: assert "abc" in str(e) f2 = client.get_function("rpc.test.strcat") assert f2("abc", 11) == "abc:11"
def test_rpc_return_func(): @tvm.register_func("rpc.test.remote_func") def addone(x): return lambda y: x+y server = rpc.Server("localhost") client = rpc.connect(server.host, server.port, key="x1") f1 = client.get_function("rpc.test.remote_func") fadd = f1(10) assert fadd(12) == 22
def test_rpc_file_exchange(): if not tvm.module.enabled("rpc"): return server = rpc.Server("localhost") remote = rpc.connect(server.host, server.port) blob = bytearray(np.random.randint(0, 10, size=(10))) remote.upload(blob, "dat.bin") rev = remote.download("dat.bin") assert (rev == blob)
def test_rpc_array(): if not tvm.module.enabled("rpc"): return x = np.random.randint(0, 10, size=(3, 4)) @tvm.register_func("rpc.test.remote_array_func") def remote_array_func(y): np.testing.assert_equal(y.asnumpy(), x) server = rpc.Server("localhost") remote = rpc.connect(server.host, server.port) r_cpu = tvm.nd.array(x, remote.cpu(0)) assert str(r_cpu.context).startswith("remote") np.testing.assert_equal(r_cpu.asnumpy(), x) fremote = remote.get_function("rpc.test.remote_array_func") fremote(r_cpu)
def check_remote(): if not tvm.module.enabled("llvm"): print("Skip because llvm is not enabled") return mlib = tvm.build(s, [A, B], "llvm", name="myadd") server = rpc.Server("localhost") remote = rpc.connect(server.host, server.port) temp = util.tempdir() ctx = remote.cpu(0) path_dso = temp.relpath("dev_lib.so") mlib.export_library(path_dso) remote.upload(path_dso) mlib = remote.load_module("dev_lib.so") mod = graph_runtime.create(graph, mlib, remote.cpu(0)) a = np.random.uniform(size=(n, )).astype(A.dtype) mod.run(x=tvm.nd.array(a, ctx)) out = tvm.nd.empty((n, ), ctx=ctx) out = mod.get_output(0, out) np.testing.assert_equal(out.asnumpy(), a + 1)
def test_rpc_executor(): host = "localhost" port = 9091 server = rpc.Server(host, port) x = sym.Variable("x") y = sym.Variable("y") z = sym.exp(y + x) shape = (10, 128) dtype = tvm.float32 shape_dict = {"x": shape, "y": shape} tmp = util.tempdir() lib_name = tmp.relpath("net.o") graph, lib, _ = nnvm.compiler.build(z, "llvm", shape_dict) # save module lib.save(lib_name) remote = rpc.connect(host, port) remote.upload(lib_name) ctx = remote.cpu(0) # load remote rlib = remote.load_module("net.o") # Create remotemodule m = graph_runtime.create(graph, rlib, remote.cpu(0)) # get member functions set_input, run, get_output = m["set_input"], m["run"], m["get_output"] na = tvm.nd.array(np.ones(shape).astype(dtype), ctx) nb = tvm.nd.array(np.ones(shape).astype(dtype), ctx) # set inputs set_input("x", na) set_input("y", nb) # execute run() # get outputs out = tvm.nd.empty(shape, dtype, ctx) get_output(0, out) np.testing.assert_allclose(out.asnumpy(), np.exp(na.asnumpy() + nb.asnumpy())) server.terminate()
# # python -m tvm.exec.rpc_server --host 0.0.0.0 --port=9090 # # After executing command above, if you see these lines below, it's # successful to start RPC server on your device. # # .. code-block:: bash # # Loading runtime library /home/YOURNAME/code/tvm/lib/libtvm_runtime.so... exec only # INFO:root:RPCServer: bind to 0.0.0.0:9090 # # In the following code block, we simply start an RPC server on the # same machine, for demonstration. This line can be omitted if we # started an remote server. # server = rpc.Server(host='0.0.0.0', port=9090) ###################################################################### # Declare and Cross Compile Kernel on Local Machine # ------------------------------------------------- # Here we will declare a simple kernel with TVM on the local machine: # n = tvm.convert(1024) A = tvm.placeholder((n, ), name='A') B = tvm.compute(A.shape, lambda *i: A(*i) + 1.0, name='B') s = tvm.create_schedule(B.op) ###################################################################### # Then we cross compile the kernel: #
###################################################################### # For demonstration, we simply start an RPC server on the same machine, # if :code:`use_rasp` is False. If you have set up the remote # environment, please change the three lines below: change the # :code:`use_rasp` to True, also change the host and port with your # device's host address and port number. use_rasp = False host = 'rasp0' port = 9090 if not use_rasp: # run server locally host = 'localhost' port = 9090 server = rpc.Server(host=host, port=port) ###################################################################### # Prepare the Pretrained Model # ---------------------------- # Back to the host machine, firstly, we need to download a MXNet Gluon # ResNet model from model zoo, which is pretrained on ImageNet. You # can found more details about this part at `Compile MXNet Models` from mxnet.gluon.model_zoo.vision import get_model from mxnet.gluon.utils import download from PIL import Image import numpy as np # only one line to get the model block = get_model('resnet18_v1', pretrained=True)
###################################################################### # For demonstration, we simply start an RPC server on the same machine, # if :code:`use_rasp` is False. If you have set up the remote # environment, please change the three lines below: change the # :code:`use_rasp` to True, also change the :code:`host` and :code:`port` # with your device's host address and port number. use_rasp = False host = 'rasp0' port = 9090 if not use_rasp: # run server locally host = 'localhost' port = 9091 server = rpc.Server(host=host, port=port, use_popen=True) ###################################################################### # Prepare the Pretrained Model # ---------------------------- # Back to the host machine, firstly, we need to download a MXNet Gluon # ResNet model from model zoo, which is pretrained on ImageNet. You # can found more details about this part at `Compile MXNet Models` from mxnet.gluon.model_zoo.vision import get_model from mxnet.gluon.utils import download from PIL import Image import numpy as np # only one line to get the model block = get_model('resnet18_v1', pretrained=True)
def check_server_drop(): """test when server drops""" try: from tvm.contrib.rpc import tracker, proxy, base from tvm.contrib.rpc.base import TrackerCode @tvm.register_func("rpc.test2.addone") def addone(x): return x + 1 def _put(tclient, value): base.sendjson(tclient._sock, value) base.recvjson(tclient._sock) tserver = tracker.Tracker("localhost", 8888) tproxy = proxy.Proxy("localhost", 8881, tracker_addr=("localhost", tserver.port)) tclient = rpc.connect_tracker("localhost", tserver.port) server1 = rpc.Server("localhost", port=9099, tracker_addr=("localhost", tserver.port), key="xyz") server2 = rpc.Server("localhost", tproxy.port, is_proxy=True, key="xyz") server3 = rpc.Server("localhost", tproxy.port, is_proxy=True, key="xyz1") # Fault tolerence to stale worker value _put(tclient, [TrackerCode.PUT, "xyz", (server1.port, "abc")]) _put(tclient, [TrackerCode.PUT, "xyz", (server1.port, "abcxxx")]) _put(tclient, [TrackerCode.PUT, "xyz", (tproxy.port, "abcxxx11")]) # Fault tolerence server timeout def check_timeout(timeout, sleeptime): def myfunc(remote): time.sleep(sleeptime) f1 = remote.get_function("rpc.test2.addone") assert f1(10) == 11 try: tclient.request_and_run("xyz", myfunc, session_timeout=timeout) except RuntimeError: pass print(tclient.text_summary()) try: remote = tclient.request("xyz", priority=0, session_timeout=timeout) remote2 = tclient.request("xyz", session_timeout=timeout) time.sleep(sleeptime) f1 = remote.get_function("rpc.test2.addone") assert f1(10) == 11 f1 = remote2.get_function("rpc.test2.addone") assert f1(10) == 11 except tvm.TVMError as e: pass check_timeout(0.01, 0.1) check_timeout(2, 0) tserver.terminate() server2.terminate() server1.terminate() server3.terminate() tproxy.terminate() except ImportError: print("Skip because tornado is not available")
# # python -m tvm.exec.rpc_server --host 0.0.0.0 --port=9090 # # After executing command above, if you see these lines below, it's # successful to start RPC server on your device. # # .. code-block:: bash # # Loading runtime library /home/YOURNAME/code/tvm/lib/libtvm_runtime.so... exec only # INFO:root:RPCServer: bind to 0.0.0.0:9090 # # In the following code block, we simply start an RPC server on the # same machine, for demonstration. This line can be omitted if we # started an remote server. # server = rpc.Server(host='0.0.0.0', port=9090, use_popen=True) ###################################################################### # Declare and Cross Compile Kernel on Local Machine # ------------------------------------------------- # Here we will declare a simple kernel with TVM on the local machine: # n = tvm.convert(1024) A = tvm.placeholder((n, ), name='A') B = tvm.compute(A.shape, lambda *i: A(*i) + 1.0, name='B') s = tvm.create_schedule(B.op) ###################################################################### # Then we cross compile the kernel: #
def test_rpc_remote_module(): if not tvm.module.enabled("rpc"): return server = rpc.Server("localhost") remote = rpc.connect(server.host, server.port) # graph n = tvm.convert(1024) A = tvm.placeholder((n, ), name='A') B = tvm.compute(A.shape, lambda *i: A(*i) + 1.0, name='B') s = tvm.create_schedule(B.op) def check_remote(): if not tvm.module.enabled("llvm"): print("Skip because llvm is not enabled") return temp = util.tempdir() ctx = remote.cpu(0) f = tvm.build(s, [A, B], "llvm", name="myadd") path_dso = temp.relpath("dev_lib.so") f.export_library(path_dso) remote.upload(path_dso) f1 = remote.load_module("dev_lib.so") a = tvm.nd.array(np.random.uniform(size=1024).astype(A.dtype), ctx) b = tvm.nd.array(np.zeros(1024, dtype=A.dtype), ctx) time_f = f1.time_evaluator(f1.entry_name, remote.cpu(0), number=10) cost = time_f(a, b).mean print('%g secs/op' % cost) np.testing.assert_equal(b.asnumpy(), a.asnumpy() + 1) def check_remote_link_cl(): """Test function to run remote code such as cl This is not enabled because there is forking issue of TVM runtime when server launches after OpenCL runtime initializes. We leave it as an example on how to do rpc when we want to do linking on remote. """ if not tvm.module.enabled("llvm"): print("Skip because llvm is not enabled") return if not tvm.module.enabled("opencl"): print("Skip because opencl is not enabled") return temp = util.tempdir() ctx = remote.cl(0) s = tvm.create_schedule(B.op) xo, xi = s[B].split(B.op.axis[0], factor=32) s[B].bind(xo, tvm.thread_axis("blockIdx.x")) s[B].bind(xi, tvm.thread_axis("threadIdx.x")) f = tvm.build(s, [A, B], "opencl", target_host="llvm", name="myadd") # Option 1: save modules separately and rely on remote compiler path_o = temp.relpath("myadd.o") path_cl = temp.relpath("myadd.cl") path_json = temp.relpath("myadd.tvm_meta.json") f.save(path_o) f.imported_modules[0].save(path_cl) remote.upload(path_o) remote.upload(path_cl) # upload meta data remote.upload(path_json) fhost = remote.load_module("myadd.o") fdev = remote.load_module("myadd.cl") fhost.import_module(fdev) a = tvm.nd.array(np.random.uniform(size=1024).astype(A.dtype), ctx) b = tvm.nd.array(np.zeros(1024, dtype=A.dtype), ctx) fhost(a, b) np.testing.assert_equal(b.asnumpy(), a.asnumpy() + 1) # Option 2: export library as a tar ball then handled by remote compiler path_tar = temp.relpath("myadd.tar") f.export_library(path_tar) remote.upload(path_tar) fhost = remote.load_module("myadd.tar") a = tvm.nd.array(np.random.uniform(size=1024).astype(A.dtype), ctx) b = tvm.nd.array(np.zeros(1024, dtype=A.dtype), ctx) fhost(a, b) np.testing.assert_equal(b.asnumpy(), a.asnumpy() + 1) check_remote()