telnet成功显示什么_TVM系列 - 终于在手机成功部署Auto-TVM

# Establish remote connection with target hardware
    tracker = rpc.connect_tracker(tracker_host, tracker_port)
    remote = tracker.request(key, priority=0,
                             session_timeout=10, max_retry=2)

static {
    boolean loadNativeRuntimeLib = true;
    try {
      try {
        tryLoadLibraryOS("tvm4j");
      } catch (UnsatisfiedLinkError e) {
        System.err.println("[WARN] TVM native library not found in path. ");
        NativeLibraryLoader.loadLibrary("tvm4j");
      }
    } catch (Throwable e) {
      System.err.println("[WARN] Couldn't find native library tvm4j.");
      e.printStackTrace();
      System.err.println("Try to load tvm4j (runtime packed version) ...");
      try {
        System.loadLibrary("tvm4j_runtime_packed");
        // if tvm runtime is packed in libtvm4j, we do not need to dlopen libtvm_runtime.so.
        loadNativeRuntimeLib = false;
      } catch (UnsatisfiedLinkError errFull) {
        System.err.println("[ERROR] Couldn't find native library tvm4j_runtime_packed.");
        throw new RuntimeException(errFull);
      }
    }

    System.err.println("libtvm4j loads successfully.");

    if (loadNativeRuntimeLib) {
      String tvmLibFilename = System.getProperty("libtvm.so.path");
      if (tvmLibFilename == null || !new File(tvmLibFilename).isFile()
          || _LIB.nativeLibInit(tvmLibFilename) != 0) {
        try {
          String runtimeLibname;
          String os = System.getProperty("os.name");
          // ref: http://lopica.sourceforge.net/os.html
          if (os.startsWith("Linux")) {
            runtimeLibname = "libtvm_runtime.so";
          } else if (os.startsWith("Mac")) {
            runtimeLibname = "libtvm_runtime.dylib";
          } else {
            // TODO(yizhi) support windows later
            throw new UnsatisfiedLinkError(os + " not supported currently");
          }
          NativeLibraryLoader.extractResourceFileToTempDir(runtimeLibname, new Action() {
            @Override public void invoke(File target) {
              System.err.println("Loading tvm runtime from " + target.getPath());
              checkCall(_LIB.nativeLibInit(target.getPath()));
            }
          });
        } catch (IOException e) {
          throw new RuntimeException(e);
        }
      }
    } else {
      _LIB.nativeLibInit(null);
    }

public RPCProcessor(Activity activity) {
    super();
    rpc_activity = activity;
    System.loadLibrary("c++_shared");
    System.loadLibrary("tvm4j_runtime_packed");
//    System.loadLibrary("tvm4j");
//    System.loadLibrary("tvm_runtime");
  }

# if "TVM_NDK_CC" not in os.environ:
    #     raise RuntimeError("Require environment variable TVM_NDK_CC"
    #                        " to be the NDK standalone compiler")
    # compiler = os.environ["TVM_NDK_CC"]
    compiler = '/data_1/Projects/android/android-ndk/android-ndk-r21/opt2/android-toolchain-arm64/bin/aarch64-linux-android-clang'
    cmd = [compiler]

for (uint64_t i = 0; i < size; ++i) {
    std::string tkey;
    CHECK(stream->Read(&tkey));
    // Currently, _lib is for DSOModule, but we
    // don't have loadbinary function for it currently
    VLOG(true) << " ProcessModuleBlob tkey: " << tkey << "n";
    if (tkey == "_lib") {
      auto dso_module = Module(make_object<LibraryModuleNode>(lib));
      modules.emplace_back(dso_module);
    } else if (tkey == "_import_tree") {
      CHECK(stream->Read(&import_tree_row_ptr));
      CHECK(stream->Read(&import_tree_child_indices));
    } else {
      std::string loadkey = "runtime.module.loadbinary_";
      std::string fkey = loadkey + tkey;
      // std::string fkey = "runtime.module.loadbinary_GraphRuntimeFactory";
      VLOG(true) << " ProcessModuleBlob fkey: " << fkey << "n";
      const PackedFunc* f = Registry::Get(fkey);
      if (f == nullptr) {
        std::string loaders = "";
        for (auto name : Registry::ListNames()) {
          if (name.rfind(loadkey, 0) == 0) {
            if (loaders.size() > 0) {
              loaders += ", ";
            }
            loaders += name.substr(loadkey.size());
          }
        }
        VLOG(true) << " ProcessModuleBlob loaders: " << loaders_info << "n";
        CHECK(f != nullptr)
            << "Binary was created using " << tkey
            << " but a loader of that name is not registered. Available loaders are " << loaders
            << ". Perhaps you need to recompile with this runtime enabled.";
      }
      Module m = (*f)(static_cast<void*>(stream));
      modules.emplace_back(m);
    }
  }

TVM_REGISTER_GLOBAL("runtime.module.loadbinary_GraphRuntimeFactory")
    .set_body_typed(GraphRuntimeFactoryModuleLoadBinary);

#include "../src/runtime/graph/graph_runtime_factory.cc"

 try:
     random_fill = remote.get_function("tvm.contrib.random.random_fill")
 except AttributeError:
     raise AttributeError("Please make sure USE_RANDOM is ON in the config.cmake "
                                         "on the remote devices")

TVM_REGISTER_GLOBAL("tvm.contrib.random.random_fill").set_body([](TVMArgs args, TVMRetValue* ret) {
  RandomThreadLocalEntry* entry = RandomThreadLocalEntry::ThreadLocal();
  DLTensor* out = args[0];
  entry->random_engine.RandomFill(out);
});

#include "../src/runtime/contrib/random/random.cc"