constant_utils.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_TOPI_DETAIL_CONSTANT_UTILS_H_
#define TVM_TOPI_DETAIL_CONSTANT_UTILS_H_
 
#include <tvm/arith/analyzer.h>
#include <tvm/runtime/logging.h>
#include <tvm/te/operation.h>
#include <tvm/tirx/analysis.h>
#include <tvm/tirx/expr.h>
 
#include <string>
#include <vector>
 
namespace tvm {
namespace topi {
namespace detail {
 
using namespace tvm::te;
 
inline bool IsConstInt(PrimExpr expr) { return expr->IsInstance<tvm::tirx::IntImmNode>(); }
 
inline bool IsConstIntArray(ffi::Array<PrimExpr> array) {
  bool is_const_int = true;
  for (auto const& elem : array) {
    is_const_int &= !elem.defined() || elem->IsInstance<tvm::tirx::IntImmNode>();
  }
  return is_const_int;
}
 
inline int64_t GetConstInt(PrimExpr expr) {
  if (expr->IsInstance<tvm::IntImmNode>()) {
    return expr.as<tvm::IntImmNode>()->value;
  }
  LOG(ERROR) << "expr must be a constant integer";
  return -1;
}
 
inline std::vector<int> GetConstIntValues(ffi::Array<PrimExpr> exprs, const std::string& var_name) {
  std::vector<int> result;
  if (!exprs.defined()) return result;
  for (auto expr : exprs) {
    TVM_FFI_ICHECK(IsConstInt(expr))
        << "All elements of " << var_name << " must be constant integers";
    result.push_back(GetConstInt(expr));
  }
  return result;
}
 
inline std::vector<int64_t> GetConstInt64Values(ffi::Array<PrimExpr> exprs,
                                                const std::string& var_name) {
  std::vector<int64_t> result;
  if (!exprs.defined()) return result;
  for (auto expr : exprs) {
    TVM_FFI_ICHECK(IsConstInt(expr))
        << "All elements of " << var_name << " must be constant integers";
    result.push_back(GetConstInt(expr));
  }
  return result;
}
 
inline bool EqualCheck(PrimExpr lhs, PrimExpr rhs) {
  tvm::tirx::ExprDeepEqual expr_equal;
  bool result = expr_equal(lhs, rhs);
  if (!result) {
    PrimExpr t = tvm::arith::Analyzer().Simplify(lhs - rhs);
    if (const IntImmNode* i = t.as<IntImmNode>()) {
      result = i->value == 0;
    }
  }
  return result;
}
 
}  // namespace detail
}  // namespace topi
}  // namespace tvm
#endif  // TVM_TOPI_DETAIL_CONSTANT_UTILS_H_