vm.h

Go to the documentation of this file.

/*
 * 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.
 */
 
#ifndef TVM_RUNTIME_VM_VM_H_
#define TVM_RUNTIME_VM_VM_H_
 
#include <tvm/ffi/extra/module.h>
#include <tvm/runtime/device_api.h>
#include <tvm/runtime/tensor.h>
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "./bytecode.h"
#include "./executable.h"
 
namespace tvm {
namespace runtime {
namespace vm {
 
enum class VMInstrumentReturnKind : int {
  kNoOp = 0,
  kSkipRun = 1,
};
 
class VMClosureObj : public ffi::Object {
 public:
  ffi::String func_name;
 
  ffi::Function impl;
  TVM_FFI_DECLARE_OBJECT_INFO_FINAL("relax.vm.Closure", VMClosureObj, ffi::Object);
};
 
class VMClosure : public ffi::ObjectRef {
 public:
  VMClosure(ffi::String func_name, ffi::Function impl);
  TVM_FFI_DEFINE_OBJECT_REF_METHODS_NOTNULLABLE(VMClosure, ffi::ObjectRef, VMClosureObj);
 
  static ffi::Function BindLastArgs(ffi::Function func, std::vector<ffi::Any> last_args);
};
 
class VMExtensionObj : public ffi::Object {
 protected:
  TVM_FFI_DECLARE_OBJECT_INFO("runtime.VMExtension", VMExtensionObj, ffi::Object);
};
 
class VMExtension : public ffi::ObjectRef {
 public:
  TVM_FFI_DEFINE_OBJECT_REF_METHODS_NOTNULLABLE(VMExtension, ffi::ObjectRef, VMExtensionObj);
};
 
class VirtualMachine : public ffi::ModuleObj {
 public:
  virtual void Init(const std::vector<Device>& devices) = 0;
  virtual void LoadExecutable(ffi::ObjectPtr<VMExecutable> exec) = 0;
  virtual VMClosure GetClosure(const ffi::String& func_name) = 0;
  virtual void InvokeClosurePacked(const ffi::ObjectRef& closure_or_packedfunc,
                                   ffi::PackedArgs args, ffi::Any* rv) = 0;
  virtual void SetInstrument(ffi::Function instrument) = 0;
 
  template <typename T, typename = std::enable_if_t<std::is_base_of<VMExtension, T>::value>>
  T GetOrCreateExtension() {
    using ContainerType = typename T::ContainerType;
    uint32_t key = ContainerType::RuntimeTypeIndex();
    if (auto it = extensions.find(key); it != extensions.end()) {
      ffi::Any value = (*it).second;
      return value.cast<T>();
    }
    auto [it, _] = extensions.emplace(key, T::Create());
    ffi::Any value = (*it).second;
    return value.cast<T>();
  }
 
  static ffi::ObjectPtr<VirtualMachine> Create();
  static VirtualMachine* GetContextPtr(ffi::AnyView arg) {
    return static_cast<VirtualMachine*>(arg.cast<void*>());
  }
 
  ~VirtualMachine() {}
 
  //--------------------------------------------------------------------------
  // The following section contains states that other builtin can depend on
  //--------------------------------------------------------------------------
  std::vector<ffi::ObjectPtr<TensorMemoryPool>> memory_pools;
  std::vector<Device> devices;
  std::unordered_map<uint32_t, Any> extensions;
};
 
}  // namespace vm
}  // namespace runtime
}  // namespace tvm
 
#endif  // TVM_RUNTIME_VM_VM_H_