structural_hash.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_NODE_STRUCTURAL_HASH_H_
#define TVM_NODE_STRUCTURAL_HASH_H_

#include <tvm/node/functor.h>
#include <tvm/runtime/data_type.h>
#include <tvm/runtime/ndarray.h>

#include <functional>
#include <string>

namespace tvm {

class BaseValueHash {
 public:
  size_t operator()(const double& key) const { return std::hash<double>()(key); }

  size_t operator()(const int64_t& key) const { return std::hash<int64_t>()(key); }

  size_t operator()(const uint64_t& key) const { return std::hash<uint64_t>()(key); }

  size_t operator()(const int& key) const { return std::hash<int>()(key); }

  size_t operator()(const bool& key) const { return std::hash<bool>()(key); }

  size_t operator()(const std::string& key) const { return std::hash<std::string>()(key); }

  size_t operator()(const runtime::DataType& key) const {
    return std::hash<int32_t>()(static_cast<int32_t>(key.code()) |
                                (static_cast<int32_t>(key.bits()) << 8) |
                                (static_cast<int32_t>(key.lanes()) << 16));
  }

  template <typename ENum, typename = typename std::enable_if<std::is_enum<ENum>::value>::type>
  bool operator()(const ENum& key) const {
    return std::hash<size_t>()(static_cast<size_t>(key));
  }
};

class StructuralHash : public BaseValueHash {
 public:
  // inheritate operator()
  using BaseValueHash::operator();
  TVM_DLL size_t operator()(const ObjectRef& key) const;
};

class SHashReducer {
 public:
  class Handler {
   public:
    virtual void SHashReduceHashedValue(size_t hashed_value) = 0;
    virtual void SHashReduce(const ObjectRef& key, bool map_free_vars) = 0;
    virtual void SHashReduceFreeVar(const runtime::Object* var, bool map_free_vars) = 0;
    virtual bool LookupHashedValue(const ObjectRef& key, size_t* hashed_value) = 0;
    virtual void MarkGraphNode() = 0;
  };

  SHashReducer() = default;
  explicit SHashReducer(Handler* handler, bool map_free_vars)
      : handler_(handler), map_free_vars_(map_free_vars) {}
  template <typename T,
            typename = typename std::enable_if<!std::is_base_of<ObjectRef, T>::value>::type>
  void operator()(const T& key) const {
    // handle normal values.
    handler_->SHashReduceHashedValue(BaseValueHash()(key));
  }
  void operator()(const ObjectRef& key) const { return handler_->SHashReduce(key, map_free_vars_); }
  void DefHash(const ObjectRef& key) const { return handler_->SHashReduce(key, true); }
  void FreeVarHashImpl(const runtime::Object* var) const {
    handler_->SHashReduceFreeVar(var, map_free_vars_);
  }

  Handler* operator->() const { return handler_; }

 private:
  Handler* handler_;
  bool map_free_vars_;
};

class SEqualReducer;
struct NDArrayContainerTrait {
  static constexpr const std::nullptr_t VisitAttrs = nullptr;
  static void SHashReduce(const runtime::NDArray::Container* key, SHashReducer hash_reduce);
  static bool SEqualReduce(const runtime::NDArray::Container* lhs,
                           const runtime::NDArray::Container* rhs, SEqualReducer equal);
};

}  // namespace tvm
#endif  // TVM_NODE_STRUCTURAL_HASH_H_