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_
 
#ifndef TVM_VM_ENABLE_PROFILER
#define TVM_VM_ENABLE_PROFILER 1
#endif
 
#include <tvm/ffi/extra/module.h>
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "../memory/memory_manager.h"
#include "./bytecode.h"
#include "./executable.h"
 
namespace tvm {
namespace runtime {
 
using memory::Allocator;
using memory::AllocatorType;
using memory::MemoryManager;
using memory::Storage;
using memory::StorageObj;
 
namespace vm {
 
enum class VMInstrumentReturnKind : int {
  kNoOp = 0,
  kSkipRun = 1,
};
 
class VMClosureObj : public Object {
 public:
  ffi::String func_name;
 
  ffi::Function impl;
  TVM_FFI_DECLARE_OBJECT_INFO_FINAL("relax.vm.Closure", VMClosureObj, Object);
};
 
class VMClosure : public ObjectRef {
 public:
  VMClosure(ffi::String func_name, ffi::Function impl);
  TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(VMClosure, ObjectRef, VMClosureObj);
 
  static ffi::Function BindLastArgs(ffi::Function func, std::vector<ffi::Any> last_args);
};
 
class VMExtensionNode : public Object {
 protected:
  TVM_FFI_DECLARE_OBJECT_INFO("runtime.VMExtension", VMExtensionNode, Object);
};
 
class VMExtension : public ObjectRef {
 public:
  TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(VMExtension, ObjectRef, VMExtensionNode);
};
 
class VirtualMachine : public ffi::ModuleObj {
 public:
  virtual void Init(const std::vector<Device>& devices,
                    const std::vector<AllocatorType>& alloc_types) = 0;
  virtual void LoadExecutable(ObjectPtr<VMExecutable> exec) = 0;
  virtual VMClosure GetClosure(const ffi::String& func_name) = 0;
  virtual void InvokeClosurePacked(const 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 ObjectPtr<VirtualMachine> Create();
  static ObjectPtr<VirtualMachine> CreateProfiler();
  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<Allocator*> allocators;
  std::vector<Device> devices;
  std::unordered_map<uint32_t, Any> extensions;
};
 
}  // namespace vm
}  // namespace runtime
}  // namespace tvm
 
#endif  // TVM_RUNTIME_VM_VM_H_