database.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_META_SCHEDULE_DATABASE_H_
#define TVM_META_SCHEDULE_DATABASE_H_

#include <tvm/ir/expr.h>
#include <tvm/ir/module.h>
#include <tvm/meta_schedule/arg_info.h>
#include <tvm/node/reflection.h>
#include <tvm/runtime/container/array.h>
#include <tvm/runtime/container/string.h>
#include <tvm/runtime/object.h>
#include <tvm/runtime/packed_func.h>
#include <tvm/target/target.h>
#include <tvm/tir/schedule/schedule.h>
#include <tvm/tir/schedule/trace.h>

namespace tvm {
namespace meta_schedule {

class WorkloadNode : public runtime::Object {
 public:
  using THashCode = size_t;
  IRModule mod;
  THashCode shash;

  void VisitAttrs(tvm::AttrVisitor* v) {
    v->Visit("mod", &mod);
    // `shash` is not visited because TVM FFI doesn't support uint64_t
  }

  static constexpr const char* _type_key = "meta_schedule.Workload";
  TVM_DECLARE_FINAL_OBJECT_INFO(WorkloadNode, runtime::Object);

  ObjectRef AsJSON() const;
};

class Workload : public runtime::ObjectRef {
 public:
  using THashCode = WorkloadNode::THashCode;
  TVM_DLL explicit Workload(IRModule mod);
  TVM_DLL explicit Workload(IRModule mod, THashCode shash);
  TVM_DLL static Workload FromJSON(const ObjectRef& json_obj);

  TVM_DEFINE_NOTNULLABLE_OBJECT_REF_METHODS(Workload, runtime::ObjectRef, WorkloadNode);
};

struct WorkloadHash {
  size_t operator()(const Workload& a) const { return a->shash; }
};

struct WorkloadEqual {
  bool operator()(const Workload& a, const Workload& b) const {
    return a->shash == b->shash && tvm::StructuralEqual()(a->mod, b->mod);
  }
};

class MeasureCandidate;

class TuningRecordNode : public runtime::Object {
 public:
  tir::Trace trace;
  Workload workload{nullptr};
  Optional<Array<FloatImm>> run_secs;
  Optional<Target> target;
  Optional<Array<ArgInfo>> args_info;

  void VisitAttrs(tvm::AttrVisitor* v) {
    v->Visit("trace", &trace);
    v->Visit("workload", &workload);
    v->Visit("run_secs", &run_secs);
    v->Visit("target", &target);
    v->Visit("args_info", &args_info);
  }

  static constexpr const char* _type_key = "meta_schedule.TuningRecord";
  TVM_DECLARE_FINAL_OBJECT_INFO(TuningRecordNode, runtime::Object);

  MeasureCandidate AsMeasureCandidate() const;
  ObjectRef AsJSON() const;
};

class TuningRecord : public runtime::ObjectRef {
 public:
  TVM_DLL explicit TuningRecord(tir::Trace trace, Workload workload,
                                Optional<Array<FloatImm>> run_secs, Optional<Target> target,
                                Optional<Array<ArgInfo>> args_info);
  TVM_DLL static TuningRecord FromJSON(const ObjectRef& json_obj, const Workload& workload);
  TVM_DEFINE_NOTNULLABLE_OBJECT_REF_METHODS(TuningRecord, runtime::ObjectRef, TuningRecordNode);
};

/* \brief The abstract interface of database. */
class DatabaseNode : public runtime::Object {
 public:
  virtual ~DatabaseNode() = default;
  virtual bool HasWorkload(const IRModule& mod) = 0;
  virtual Workload CommitWorkload(const IRModule& mod) = 0;
  virtual void CommitTuningRecord(const TuningRecord& record) = 0;
  virtual Array<TuningRecord> GetTopK(const Workload& workload, int top_k) = 0;
  virtual Array<TuningRecord> GetAllTuningRecords() = 0;
  virtual int64_t Size() = 0;
  virtual Optional<TuningRecord> QueryTuningRecord(const IRModule& mod, const Target& target,
                                                   const String& workload_name);
  virtual Optional<tir::Schedule> QuerySchedule(const IRModule& mod, const Target& target,
                                                const String& workload_name);
  virtual Optional<IRModule> QueryIRModule(const IRModule& mod, const Target& target,
                                           const String& workload_name);

  static constexpr const char* _type_key = "meta_schedule.Database";
  TVM_DECLARE_BASE_OBJECT_INFO(DatabaseNode, runtime::Object);
};

class PyDatabaseNode : public DatabaseNode {
 public:
  using FHasWorkload = runtime::TypedPackedFunc<bool(const IRModule&)>;
  using FCommitWorkload = runtime::TypedPackedFunc<Workload(const IRModule&)>;
  using FCommitTuningRecord = runtime::TypedPackedFunc<void(const TuningRecord&)>;
  using FGetTopK = runtime::TypedPackedFunc<Array<TuningRecord>(const Workload&, int)>;
  using FGetAllTuningRecords = runtime::TypedPackedFunc<Array<TuningRecord>()>;
  using FQueryTuningRecord = runtime::TypedPackedFunc<Optional<TuningRecord>(
      const IRModule&, const Target&, const String&)>;
  using FQuerySchedule = runtime::TypedPackedFunc<Optional<tir::Schedule>(
      const IRModule&, const Target&, const String&)>;
  using FQueryIRModule =
      runtime::TypedPackedFunc<Optional<IRModule>(const IRModule&, const Target&, const String&)>;
  using FSize = runtime::TypedPackedFunc<int64_t()>;

  FHasWorkload f_has_workload;
  FCommitWorkload f_commit_workload;
  FCommitTuningRecord f_commit_tuning_record;
  FGetTopK f_get_top_k;
  FGetAllTuningRecords f_get_all_tuning_records;
  FQueryTuningRecord f_query_tuning_record;
  FQuerySchedule f_query_schedule;
  FQueryIRModule f_query_ir_module;
  FSize f_size;

  void VisitAttrs(tvm::AttrVisitor* v) {
    // PackedFuncs are all not visited, because the reflection system doesn't take care of them,
    // so it cannot be accessible on the python side. If there is such need from the future,
    // we can then add corresponding accessor methods to help access on python.
    // `f_has_workload` is not visited
    // `f_commit_workload` is not visited
    // `f_commit_tuning_record` is not visited
    // `f_get_top_k` is not visited
    // `f_get_all_tuning_records` is not visited
    // `f_query_tuning_record` is not visited
    // `f_query_schedule` is not visited
    // `f_query_ir_module` is not visited
    // `f_size` is not visited
  }

  bool HasWorkload(const IRModule& mod) final {
    ICHECK(f_has_workload != nullptr) << "PyDatabase's HasWorkload method not implemented!";
    return f_has_workload(mod);
  }

  Workload CommitWorkload(const IRModule& mod) final {
    ICHECK(f_commit_workload != nullptr) << "PyDatabase's CommitWorkload method not implemented!";
    return f_commit_workload(mod);
  }

  void CommitTuningRecord(const TuningRecord& record) final {
    ICHECK(f_commit_tuning_record != nullptr)
        << "PyDatabase's CommitTuningRecord method not implemented!";
    f_commit_tuning_record(record);
  }

  Array<TuningRecord> GetTopK(const Workload& workload, int top_k) final {
    ICHECK(f_get_top_k != nullptr) << "PyDatabase's GetTopK method not implemented!";
    return f_get_top_k(workload, top_k);
  }

  Array<TuningRecord> GetAllTuningRecords() final {
    ICHECK(f_get_all_tuning_records != nullptr)
        << "PyDatabase's GetAllTuningRecords method not implemented!";
    return f_get_all_tuning_records();
  }

  Optional<TuningRecord> QueryTuningRecord(const IRModule& mod, const Target& target,
                                           const String& workload_name) final {
    if (f_query_tuning_record == nullptr) {
      return DatabaseNode::QueryTuningRecord(mod, target, workload_name);
    } else {
      return f_query_tuning_record(mod, target, workload_name);
    }
  }

  Optional<tir::Schedule> QuerySchedule(const IRModule& mod, const Target& target,
                                        const String& workload_name) final {
    if (f_query_schedule == nullptr) {
      return DatabaseNode::QuerySchedule(mod, target, workload_name);
    } else {
      return f_query_schedule(mod, target, workload_name);
    }
  }

  Optional<IRModule> QueryIRModule(const IRModule& mod, const Target& target,
                                   const String& workload_name) final {
    if (f_query_ir_module == nullptr) {
      return DatabaseNode::QueryIRModule(mod, target, workload_name);
    } else {
      return f_query_ir_module(mod, target, workload_name);
    }
  }

  int64_t Size() final {
    ICHECK(f_size != nullptr) << "PyDatabase's Size method not implemented!";
    return f_size();
  }

  static constexpr const char* _type_key = "meta_schedule.PyDatabase";
  TVM_DECLARE_FINAL_OBJECT_INFO(PyDatabaseNode, DatabaseNode);
};

class Database : public runtime::ObjectRef {
 public:
  TVM_DLL static Database MemoryDatabase();
  TVM_DLL static Database ScheduleFnDatabase(
      runtime::TypedPackedFunc<bool(tir::Schedule)> schedule_fn);
  TVM_DLL static Database JSONDatabase(String path_workload, String path_tuning_record,
                                       bool allow_missing);
  TVM_DLL static Database UnionDatabase(Array<Database, void> databases);
  TVM_DLL static Database OrderedUnionDatabase(Array<Database, void> databases);
  TVM_DLL static Database PyDatabase(PyDatabaseNode::FHasWorkload f_has_workload,
                                     PyDatabaseNode::FCommitWorkload f_commit_workload,
                                     PyDatabaseNode::FCommitTuningRecord f_commit_tuning_record,
                                     PyDatabaseNode::FGetTopK f_get_top_k,
                                     PyDatabaseNode::FGetAllTuningRecords f_get_all_tuning_records,
                                     PyDatabaseNode::FQueryTuningRecord f_query_tuning_record,
                                     PyDatabaseNode::FQuerySchedule f_query_schedule,
                                     PyDatabaseNode::FQueryIRModule f_query_ir_module,
                                     PyDatabaseNode::FSize f_size);
  static Optional<Database> Current();
  void EnterWithScope();
  void ExitWithScope();

  TVM_DEFINE_MUTABLE_NOTNULLABLE_OBJECT_REF_METHODS(Database, runtime::ObjectRef, DatabaseNode);
};

}  // namespace meta_schedule
}  // namespace tvm

#endif  // TVM_META_SCHEDULE_DATABASE_H_