/**
 * Copyright 2019-2020 Huawei Technologies Co., Ltd
 *
 * Licensed 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.
 */

#include "common/helper/model_cache_helper.h"

#include <cstdio>
#include <fstream>
#include <functional>

#include "common/model_parser/model_parser.h"
#include "framework/common/helper/model_helper.h"
#include "graph/detail/model_serialize_imp.h"
#include "graph/utils/graph_utils.h"
#include "graph/utils/tensor_utils.h"
#include "init/gelib.h"
#include "proto/ge_ir.pb.h"

using namespace std;

namespace {
const char *const kTbeKernelInfoStoreName = "AIcoreEngine";
const char *const kGraphName = "temp_name";
// Keys of json
const char *const kNodeNum = "nodeNum";
const char *const kEdgeNum = "edgeNum";
const char *const kGraphHash = "graphHash";
const char *const kNodeHash = "nodeHash";
const char *const kHash = "hash";
const char *const kSessionId = "sessionId";
const char *const kDeviceId = "deviceId";
const char *const kJobId = "jobId";
const char *const kGraphMemMaxSize = "graphMemMaxSize";
const char *const kVarMemMaxSize = "varMemMaxSize";
const char *const kVarMemLogicBase = "varMemLogicBase";
const char *const kUseMaxMemSize = "useMaxMemSize";
const char *const kMemResourceMap = "memResourceMap";
const char *const kMemType = "memType";
const char *const kTotalSize = "totalSize";
const char *const kVarMemSize = "varMemSize";
const char *const kVarResource = "varResource";
const char *const kVarAddrMgrMap = "varAddrMgrMap";
const char *const kName = "name";
const char *const kAddress = "address";
const char *const kOffset = "offset";
const char *const kMemoryType = "memoryType";
const char *const kTensorDesc = "tensorDesc";
const char *const kDataType = "dataType";
const char *const kShape = "shape";
const char *const kLayout = "layout";
const char *const kOriginDataType = "originDataType";
const char *const kOriginShape = "originShape";
const char *const kOriginLayout = "originLayout";
const char *const kRealDimCnt = "realDimCnt";
const char *const kCurVarTensorDescMap = "curVarTensorDescMap";
const char *const kTransRoads = "transRoads";
const char *const kTransRoad = "transRoad";
const char *const kNodeType = "nodeType";
const char *const kInputTensorDesc = "inputTensorDesc";
const char *const kOutputTensorDesc = "outputTensorDesc";
const char *const kChangedGraphId = "changedGraphId";
const char *const kAllocatedGraphId = "allocatedGraphId";
const char *const kGraphId = "graphId";
const char *const kVarBroadcastInfo = "varBroadcastInfo";
const char *const kBroadcastName = "broadcastName";
const char *const kIdx = "idx";
const char *const kInputOffset = "inputOffset";
const char *const kInputSize = "inputSize";
const char *const kOutputOffset = "outputOffset";
const char *const kOutputSize = "outputSize";
// Suffix of cache files
const char *const kBeforeVarManagerSuffix = "_before_build_var_manager.json";
const char *const kAfterVarManagerSuffix = "_after_build_var_manager.json";
const char *const kManifestSuffix = ".manifest";
const char *const kOmSuffix = ".om";
}  // namespace

namespace ge {
map<uint32_t, uint32_t> ModelCacheHelper::graph_id_run_times_;
ModelCacheHelper::ModelCacheHelper(uint64_t session_id, uint32_t graph_id, ComputeGraphPtr &compute_graph)
    : session_id_(session_id),
      graph_id_(graph_id),
      compute_graph_(compute_graph),
      is_cache_path_valid_for_output(false) {
  if (graph_id_run_times_.count(graph_id) == 0) {
    graph_id_run_times_[graph_id] = 1;
  } else {
    graph_id_run_times_[graph_id] = graph_id_run_times_[graph_id] + 1;
  }
  for (const auto &node : compute_graph_->GetDirectNode()) {
    bool is_variable = (node->GetType() == VARIABLE) || (node->GetType() == VARIABLEV2) ||
                       (node->GetType() == VARHANDLEOP) || (node->GetType() == CONSTANTOP);
    if (!is_variable) {
      continue;
    }
    var_names_.insert(node->GetName());
  }
  std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
  if (instance_ptr != nullptr && instance_ptr->IsIncreBuild()) {
    std::string cache_path = instance_ptr->GetIncreBuildCachePath();
    GELOGD("Incre build path conf: %s", cache_path.c_str());
    string fake_file_path = cache_path + to_string(graph_id_) + kManifestSuffix;
    if (CheckOutputPathValid(fake_file_path)) {
      is_cache_path_valid_for_output = true;
    } else {
      GELOGW("Invalid cache path for output.");
    }
    std::string real_cache_path = RealPath(cache_path.c_str());
    if (real_cache_path.empty()) {
      GELOGW("Invalid incre build cache path conf: %s", cache_path.c_str());
      return;
    }
    cache_path_ = real_cache_path + '/';
    GELOGD("Try to use incre build cache path: %s", cache_path_.c_str());
  }
}

ModelCacheHelper::~ModelCacheHelper() { var_names_.clear(); }

bool ModelCacheHelper::IsModelCacheHit() const {
  CacheInfo cache_info;
  if (GetCacheInfo(cache_info) != SUCCESS) {
    GELOGI("Get cache info of graph id[%u] failed.", graph_id_);
    return false;
  }
  // Check number of nodes and edges first.
  if (cache_info.node_num != compute_graph_->GetDirectNodesSize()) {
    GELOGI("Graph id[%u] cache miss: the node number of the graph does not match the cache info.", graph_id_);
    return false;
  }
  size_t edge_num = 0;
  for (const auto &node : compute_graph_->GetDirectNode()) {
    for (const auto &anchor : node->GetAllInAnchors()) {
      edge_num += anchor->GetPeerAnchors().size();
    }
  }
  if (cache_info.edge_num != edge_num) {
    GELOGI("Graph id[%u] cache miss: the edge number of the graph does not match the cache info.", graph_id_);
    return false;
  }
  size_t compute_graph_hash;
  auto ret = GetComputeGraphHash(compute_graph_hash);
  if (ret != SUCCESS || cache_info.graph_hash != compute_graph_hash) {
    GELOGI("Graph id[%u] cache miss: the hash code of the graph does not match the cache info.", graph_id_);
    return false;
  }
  if (!IsNodeHashSameAsCache(cache_info.nodes_hash)) {
    GELOGI("Graph id[%u] cache miss: the hash code of node does not match the cache info.", graph_id_);
    return false;
  }

  string var_manager_cache =
    to_string(graph_id_) + "_" + to_string(graph_id_run_times_[graph_id_]) + kBeforeVarManagerSuffix;
  Json var_manager_json;
  if (LoadJsonFromFile(var_manager_cache, var_manager_json) != SUCCESS) {
    GELOGW("Fail to load json from cache file: %s", var_manager_cache.c_str());
    return false;
  }
  if (!IsVarManagerSameAsCache(var_manager_json)) {
    GELOGI("Graph id[%u] cache miss: the VarManager does not match the cache info.", graph_id_);
    return false;
  }
  GELOGI("Graph id[%u] cache hit.", graph_id_);
  return true;
}

Status ModelCacheHelper::RefreshComputeGraph(const ComputeGraphPtr &compute_graph) {
  if (compute_graph->IsValid()) {
    compute_graph_ = compute_graph;
    var_names_.clear();
    for (const auto &node : compute_graph_->GetDirectNode()) {
      bool is_variable = (node->GetType() == VARIABLE) || (node->GetType() == VARIABLEV2) ||
                         (node->GetType() == VARHANDLEOP) || (node->GetType() == CONSTANTOP);
      if (!is_variable) {
        continue;
      }
      var_names_.insert(node->GetName());
    }
    return SUCCESS;
  } else {
    GELOGW("Invalid compute graph.");
    return FAILED;
  }
}

Status ModelCacheHelper::ClearCache(uint32_t graph_id) const {
  if (!is_cache_path_valid_for_output) {
    GELOGW("Invalid cache path.");
    return SUCCESS;
  }
  string manifest_file = cache_path_ + to_string(graph_id) + kManifestSuffix;
  string manifest_file_path = RealPath(manifest_file.c_str());
  int ret;
  if (!manifest_file_path.empty()) {
    ret = remove(manifest_file_path.c_str());
    // If remove file failed, print the warning log
    if (ret != 0) {
      GELOGW("Clear cache [%s] failed.", manifest_file_path.c_str());
    }
  }
  string before_var_manager_file = cache_path_ + to_string(graph_id) + kManifestSuffix;
  string before_var_manager_file_path = RealPath(before_var_manager_file.c_str());
  if (!before_var_manager_file_path.empty()) {
    ret = remove(before_var_manager_file_path.c_str());
    if (ret != 0) {
      GELOGW("Clear cache [%s] failed.", before_var_manager_file_path.c_str());
    }
  }
  string after_var_manager_file = cache_path_ + to_string(graph_id) + kManifestSuffix;
  string after_var_manager_file_path = RealPath(after_var_manager_file.c_str());
  if (!after_var_manager_file_path.empty()) {
    ret = remove(after_var_manager_file_path.c_str());
    if (ret != 0) {
      GELOGW("Clear cache [%s] failed.", after_var_manager_file_path.c_str());
    }
  }
  string om_file = cache_path_ + to_string(graph_id) + kManifestSuffix;
  string om_file_path = RealPath(om_file.c_str());
  if (!om_file_path.empty()) {
    ret = remove(om_file_path.c_str());
    if (ret != 0) {
      GELOGW("Clear cache [%s] failed.", om_file_path.c_str());
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::RecoverVarManagerFromCache() const {
  string var_manager_cache =
    to_string(graph_id_) + "_" + to_string(graph_id_run_times_[graph_id_]) + kAfterVarManagerSuffix;
  Json var_manager_json;
  if (LoadJsonFromFile(var_manager_cache, var_manager_json) != SUCCESS) {
    GELOGW("Fail to load json from cache file: %s", var_manager_cache.c_str());
    return FAILED;
  }

  Json mem_resource_json = move(var_manager_json[kMemResourceMap]);
  auto ret = RecoverMemResource(mem_resource_json);
  if (ret != SUCCESS) {
    GELOGW("Recover VarManager from cache failed.[MemResource]");
    return FAILED;
  }
  Json var_resource_json = move(var_manager_json[kVarResource]);
  ret = RecoverAllocatedGraphId(var_resource_json[kAllocatedGraphId]);
  if (ret != SUCCESS) {
    GELOGW("Recover VarManager from cache failed.[AllocatedGraphId]");
    return FAILED;
  }
  ret = RecoverChangedGraphId(var_resource_json[kChangedGraphId]);
  if (ret != SUCCESS) {
    GELOGW("Recover VarManager from cache failed.[ChangedGraphId]");
    return FAILED;
  }
  ret = RecoverBroadcastInfo(var_resource_json[kVarBroadcastInfo]);
  if (ret != SUCCESS) {
    GELOGW("Recover VarManager from cache failed.[VarBroadcastInfo]");
    return FAILED;
  }
  ret = RecoverVarAddrAndTensorDesc(var_resource_json[kVarAddrMgrMap]);
  if (ret != SUCCESS) {
    GELOGW("Recover VarManager from cache failed.[VarAddrMgrMap & CurVarTensorDesc]");
    return FAILED;
  }
  ret = RecoverTransRoads(var_resource_json[kTransRoads]);
  if (ret != SUCCESS) {
    GELOGW("Recover VarManager from cache failed.[TransRoads]");
    return FAILED;
  }
  GELOGI("Recover VarManager from cache[%s] success.", cache_path_.c_str());
  return SUCCESS;
}

Status ModelCacheHelper::GetNodesNeedRecompile(ComputeGraphPtr &graph, vector<NodePtr> &nodes) {
  std::shared_ptr<GELib> instance = ge::GELib::GetInstance();
  if (instance == nullptr || !instance->InitFlag()) {
    GELOGW("RecompileNodes failed.");
    return ge::GE_CLI_GE_NOT_INITIALIZED;
  }
  // Collect aicore ops for recompile
  for (auto &node : graph->GetDirectNode()) {
    if (node == nullptr) {
      continue;
    }
    auto op_desc = node->GetOpDesc();
    if (op_desc == nullptr) {
      continue;
    }
    // Get op kernel lib name
    string kernel_lib_name = op_desc->GetOpKernelLibName();
    if (kernel_lib_name.empty()) {
      // reset op kernel lib
      (void)instance->DNNEngineManagerObj().GetDNNEngineName(node);
      kernel_lib_name = op_desc->GetOpKernelLibName();
      if (kernel_lib_name.empty()) {
        GELOGW("Get node:%s, type:%s kernel lib failed.", node->GetName().c_str(), op_desc->GetType().c_str());
        continue;
      }
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::RecompileNodes(GeModelPtr &ge_model) {
  std::shared_ptr<GELib> instance = ge::GELib::GetInstance();
  if (instance == nullptr || !instance->InitFlag()) {
    GELOGW("RecompileNodes failed.");
    return ge::GE_CLI_GE_NOT_INITIALIZED;
  }
  // Get aicore ops kernel info store.
  OpsKernelInfoStorePtr kernel_info = instance->OpsKernelManagerObj().GetOpsKernelInfoStore(kTbeKernelInfoStoreName);
  if (kernel_info == nullptr) {
    GELOGW("Get %s ops kernel info store failed", kTbeKernelInfoStoreName);
    return INTERNAL_ERROR;
  }

  auto compute_graph = GraphUtils::GetComputeGraph(ge_model->GetGraph());
  vector<NodePtr> node_vec;
  auto ret = GetNodesNeedRecompile(compute_graph, node_vec);
  GE_CHK_BOOL_EXEC_WARN(ret == ge::SUCCESS, return ret, "Get nodes need recompiling failed");
  // Recompile aicore ops
  ret = kernel_info->CompileOp(node_vec);
  GE_CHK_BOOL_EXEC_WARN(ret == ge::SUCCESS, return ret, "Recompile op failed");
  const TBEKernelStore &tbekernel_store = ge_model->GetTBEKernelStore();
  TBEKernelStore tbe_kernel_store;
  for (const ge::NodePtr &n : compute_graph->GetDirectNode()) {
    auto node_op_desc = n->GetOpDesc();
    GE_IF_BOOL_EXEC(node_op_desc == nullptr, continue);
    TBEKernelPtr tbe_kernel = node_op_desc->TryGetExtAttr(ge::OP_EXTATTR_NAME_TBE_KERNEL, TBEKernelPtr());
    if (tbe_kernel == nullptr) {
      // Load tbe kernel from tbe_kernel_store to op if op was not recompiled
      auto op_desc = n->GetOpDesc();
      tbekernel_store.LoadTBEKernelBinToOpDesc(op_desc);
      GELOGD("LoadOmModelFromCache: Load tbe kernel bin to op desc[%s].", op_desc->GetName().c_str());
    }
    tbe_kernel = node_op_desc->TryGetExtAttr(ge::OP_EXTATTR_NAME_TBE_KERNEL, TBEKernelPtr());
    GE_IF_BOOL_EXEC(tbe_kernel == nullptr, continue);
    // Refresh tbe kernel in tbe_kernel_store
    tbe_kernel_store.AddTBEKernel(tbe_kernel);
    GELOGD("Add tbe kernel bin %s", tbe_kernel->GetName().c_str());
  }
  GE_CHK_BOOL_EXEC_WARN(tbe_kernel_store.Build(), return FAILED, "TBE Kernels store build failed!");
  ge_model->SetTBEKernelStore(tbe_kernel_store);
  return SUCCESS;
}

Status ModelCacheHelper::GetNodesHash(map<std::string, size_t> &hash_map) const {
  vector<NodePtr> nodes;
  GraphUtils::TopologicalSortingByName(compute_graph_, nodes);
  ModelSerializeImp model_serialize_imp;
  std::hash<string> node_hash;
  for (const auto &node : nodes) {
    if (node == nullptr) {
      continue;
    }
    proto::OpDef op_def;
    bool is_framework_op = (node->GetType() == FRAMEWORKOP);
    int32_t framework_type = 0;
    if (is_framework_op) {
      AttrUtils::GetInt(node->GetOpDesc(), ge::ATTR_NAME_FRAMEWORK_FWK_TYPE, framework_type);
      AttrUtils::SetInt(node->GetOpDesc(), ge::ATTR_NAME_FRAMEWORK_FWK_TYPE, 0);
    }
    bool ret = model_serialize_imp.SerializeNode(node, &op_def, is_framework_op);
    op_def.set_id(0);  // Id of op is not stable because of parallel parsing
    // Clear weights attr in constant.
    auto attr = op_def.mutable_attr();
    if (op_def.type() == CONSTANT || op_def.type() == CONSTANTOP) {
      attr->erase(ATTR_NAME_WEIGHTS);
    }
    if (is_framework_op) {
      AttrUtils::SetInt(node->GetOpDesc(), ge::ATTR_NAME_FRAMEWORK_FWK_TYPE, framework_type);
    }
    if (!ret) {
      GELOGW("Fail to serialize node[%s].", node->GetName().c_str());
      return INTERNAL_ERROR;
    }
    string prototxt;
    ret = google::protobuf::TextFormat::PrintToString(op_def, &prototxt);
    if (!ret) {
      GELOGW("Print OpDef to string failed.");
      hash_map.clear();
      return INTERNAL_ERROR;
    }
    size_t hash_code = node_hash(prototxt);
    hash_map[node->GetName()] = hash_code;
  }
  return SUCCESS;
}

Status ModelCacheHelper::GetComputeGraphHash(size_t &hash) const {
  proto::GraphDef graph_proto;
  ModelSerializeImp model_serialize_imp;
  // The name of compute graph may be generated randomly, so replace it temporarily.
  const string origin_name = compute_graph_->GetName();
  compute_graph_->SetName(kGraphName);
  bool serialize_ret = model_serialize_imp.SerializeGraph(compute_graph_, &graph_proto);
  graph_proto.clear_op();
  if (!serialize_ret) {
    GELOGW("Serialize graph failed.");
    hash = 0;
    return INTERNAL_ERROR;
  }
  compute_graph_->SetName(origin_name);
  // Generate proto text of GraphDef
  string prototxt;
  bool print_ret = google::protobuf::TextFormat::PrintToString(graph_proto, &prototxt);
  if (!print_ret) {
    GELOGW("Print GraphDef to string failed.");
    hash = 0;
    return INTERNAL_ERROR;
  }
  // Get the hash code of proto text
  std::hash<string> graph_hash;
  hash = graph_hash(prototxt);
  return SUCCESS;
}

Status ModelCacheHelper::SaveJsonToFile(const string &file_name, const Json &json) const {
  if (!is_cache_path_valid_for_output) {
    GELOGW("Invalid cache path.");
    return PARAM_INVALID;
  }
  // Check whether the manifest exists, if not, create it.
  string real_path = RealPath(cache_path_.c_str());
  if (real_path.empty()) {
    GELOGW("File path is invalid. please check cache path: %s", cache_path_.c_str());
    return FAILED;
  }
  const string path = cache_path_ + file_name;
  const int FILE_AUTHORITY = 0600;
  int fd = mmOpen2(path.c_str(), M_WRONLY | M_CREAT | O_TRUNC, FILE_AUTHORITY);
  if (fd < 0) {
    GELOGW("Fail to open the file: %s.", path.c_str());
    return INTERNAL_ERROR;
  }
  if (mmClose(fd) != 0) {
    GELOGW("Fail to close the file: %s.", path.c_str());
    return INTERNAL_ERROR;
  }

  // Write json into cache file
  ofstream ofs;
  ofs.open(path);
  if (!ofs.is_open()) {
    GELOGW("Fail to open the file: %s.", path.c_str());
    return INTERNAL_ERROR;
  }
  ofs << json << std::endl;
  ofs.close();
  return SUCCESS;
}

Status ModelCacheHelper::LoadJsonFromFile(const string &file_name, Json &json) const {
  if (!json.is_null()) {
    GELOGW("Input param json type should be null.");
    return PARAM_INVALID;
  }
  string real_path = RealPath(cache_path_.c_str());
  if (real_path.empty()) {
    GELOGW("File path is invalid. please check cache path: %s", cache_path_.c_str());
    return FAILED;
  }
  const string path = cache_path_ + file_name;
  if (!CheckInputPathValid(path)) {
    GELOGW("Invalid cache path for input:%s.", path.c_str());
    return FAILED;
  }
  string cache_real_path = RealPath(path.c_str());
  if (cache_real_path.empty()) {
    GELOGI("File[%s] is not found.", path.c_str());
    return FAILED;
  }
  // Read json from cache file
  ifstream ifs;
  ifs.open(path);
  if (!ifs.is_open()) {
    GELOGW("Fail to open the file: %s.", path.c_str());
    return INTERNAL_ERROR;
  }
  try {
    ifs >> json;
  } catch (nlohmann::detail::parse_error e) {
    GELOGW("Fail to load json from file, json throw an error:%s.", e.what());
    return INTERNAL_ERROR;
  } catch (nlohmann::detail::invalid_iterator e) {
    GELOGW("Fail to load json from file, json throw an error:%s.", e.what());
    return INTERNAL_ERROR;
  } catch (nlohmann::detail::type_error e) {
    GELOGW("Fail to load json from file, json throw an error:%s.", e.what());
    return INTERNAL_ERROR;
  } catch (nlohmann::detail::out_of_range e) {
    GELOGW("Fail to load json from file, json throw an error:%s.", e.what());
    return INTERNAL_ERROR;
  } catch (nlohmann::detail::other_error e) {
    GELOGW("Fail to load json from file, json throw an error:%s.", e.what());
    return INTERNAL_ERROR;
  }

  if (!json.is_object()) {
    GELOGW("Fail to load the json file: %s.", path.c_str());
    return INTERNAL_ERROR;
  }
  return SUCCESS;
}

Status ModelCacheHelper::SaveCacheInfoToCache() const {
  // Generate cache json
  // example: {"edgeNum":6,"nodeNum":7,"graphCache":134714827475991356}
  Json cache_json;
  try {
    cache_json[kNodeNum] = compute_graph_->GetDirectNodesSize();
    size_t edge_num = 0;
    for (const auto &node : compute_graph_->GetDirectNode()) {
      for (const auto &anchor : node->GetAllInAnchors()) {
        edge_num += anchor->GetPeerAnchors().size();
      }
    }
    cache_json[kEdgeNum] = edge_num;
    size_t hash = 0;
    auto ret = GetComputeGraphHash(hash);
    if (ret != SUCCESS) {
      GELOGW("Error occur when generate graph hash code.");
      return ret;
    }
    cache_json[kGraphHash] = hash;
    Json nodes_hash_json;
    ret = GetNodesHashMapJson(nodes_hash_json);
    if (ret != SUCCESS) {
      GELOGW("Error occur when generate nodes hash code.");
      return ret;
    }
    cache_json[kNodeHash] = nodes_hash_json;
  } catch (const std::exception &e) {
    GELOGW("Fail to generate cache info json. Error message: %s", e.what());
    return INTERNAL_ERROR;
  }
  string cache_manifest = to_string(graph_id_) + "_" + to_string(graph_id_run_times_[graph_id_]) + kManifestSuffix;

  auto ret = SaveJsonToFile(cache_manifest, cache_json);
  if (ret != SUCCESS) {
    GELOGW("Fail to save cache info to json file, path: %s.", cache_path_.c_str());
    return ret;
  }
  return SUCCESS;
}

Status ModelCacheHelper::GetCacheInfo(CacheInfo &cache_info) const {
  string cache_manifest = to_string(graph_id_) + "_" + to_string(graph_id_run_times_[graph_id_]) + kManifestSuffix;
  Json cache_json;
  if (LoadJsonFromFile(cache_manifest, cache_json) != SUCCESS) {
    GELOGW("Fail to load json from cache file: %s", cache_manifest.c_str());
    return INTERNAL_ERROR;
  }
  if (!cache_json.is_object()) {
    GELOGW("Manifest should be a json object");
    return INTERNAL_ERROR;
  }
  try {
    cache_info.node_num = cache_json[kNodeNum];
    cache_info.edge_num = cache_json[kEdgeNum];
    cache_info.graph_hash = cache_json[kGraphHash];
    Json nodes_hash_json = cache_json[kNodeHash];
    if (!(nodes_hash_json.is_null() || nodes_hash_json.is_array())) {
      GELOGW("Nodes hash in cache should be null or array.");
      return FAILED;
    }
    for (const auto &iter : nodes_hash_json) {
      cache_info.nodes_hash[iter[kName].get<std::string>()] = iter[kHash].get<size_t>();
    }
  } catch (const std::exception &e) {
    GELOGW("Fail to get info from json file. Error message: %s", e.what());
    return INTERNAL_ERROR;
  }
  return SUCCESS;
}

bool ModelCacheHelper::IsAllocatedGraphIdSameAsCache(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return false;
  }
  // Compare allocated graph id info between json and VarManager
  std::map<std::string, uint32_t> allocated_graph_id;
  auto ret = ParseAllocatedGraphIdFromJson(json, allocated_graph_id);
  if (ret != SUCCESS) {
    GELOGW("Fail to parse AllocatedGraphId from Json.");
    return false;
  }
  for (const auto &iter : allocated_graph_id) {
    uint32_t graph_id = 0;
    ret = VarManager::Instance(session_id_)->GetAllocatedGraphId(iter.first, graph_id);
    if (ret != SUCCESS) {
      GELOGW("Fail to find allocated graph id of var[%s].", iter.first.c_str());
      return false;
    }
    if (graph_id != iter.second) {
      GELOGW("The allocated graph id of variable[%s] in cache is different from VarManager.", iter.first.c_str());
      return false;
    }
  }
  return true;
}

bool ModelCacheHelper::IsNodeHashSameAsCache(const map<std::string, size_t> &hash_map) const {
  map<std::string, size_t> cur_hash_map;
  GetNodesHash(cur_hash_map);
  if (hash_map.size() != cur_hash_map.size()) {
    GELOGI("The number of hash code is different from cache info.");
    return false;
  }
  for (const auto &iter : cur_hash_map) {
    if (hash_map.count(iter.first) == 0) {
      GELOGI("Node[%s] is not found in cache info.", iter.first.c_str());
      return false;
    }
    if (hash_map.at(iter.first) != iter.second) {
      GELOGI("The hash code of node[%s] is different from cache info.", iter.first.c_str());
      return false;
    }
  }
  return true;
}

bool ModelCacheHelper::IsMemResourceSameAsCache(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return false;
  }
  // Compare var mem size info between json and VarManager
  std::map<rtMemType_t, int64_t> var_mem_size;
  auto ret = ParseMemResourceFromJson(json, var_mem_size);
  if (ret != SUCCESS) {
    GELOGW("Fail to parse MemResource from Json.");
    return false;
  }
  for (const auto &iter : var_mem_size) {
    int64_t mem_size = VarManager::Instance(session_id_)->GetVarMemSize(iter.first);
    if (mem_size != iter.second) {
      GELOGW("The var mem size of memory_type[%u] in cache is different from VarManager.", iter.first);
      return false;
    }
  }
  return true;
}

bool ModelCacheHelper::IsChangedGraphIdSameAsCache(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return false;
  }
  // Compare variable changed graph id info between json and VarManager
  std::map<std::string, uint32_t> changed_graph_id;
  auto ret = ParseChangedGraphIdFromJson(json, changed_graph_id);
  if (ret != SUCCESS) {
    GELOGW("Fail to parse ChangedGraphId from Json.");
    return false;
  }
  for (const auto &iter : changed_graph_id) {
    uint32_t graph_id = 0;
    ret = VarManager::Instance(session_id_)->GetChangedGraphId(iter.first, graph_id);
    if (ret != SUCCESS) {
      GELOGW("Fail to find changed graph id of var[%s].", iter.first.c_str());
      return false;
    }
    if (graph_id != iter.second) {
      GELOGW("The changed graph id of variable[%s] in cache is different from VarManager.", iter.first.c_str());
      return false;
    }
  }
  return true;
}

bool ModelCacheHelper::IsCurVarTensorDescSameAsCache(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return false;
  }
  // Compare variable tensor desc info between json and VarManager
  std::unordered_map<std::string, ge::GeTensorDesc> cur_var_tensor_desc;
  auto ret = ParseCurVarTensorDescMapFromJson(json, cur_var_tensor_desc);
  if (ret != SUCCESS) {
    GELOGW("Fail to parse CurVarTensorDesc from Json.");
    return false;
  }
  for (const auto &iter : cur_var_tensor_desc) {
    GeTensorDesc tensor_desc;
    ret = VarManager::Instance(session_id_)->GetCurVarDesc(iter.first, tensor_desc);
    if (ret != SUCCESS) {
      GELOGW("Fail to find tensor desc of var[%s].", iter.first.c_str());
      return false;
    }
    uint32_t l_real_dim_cnt = 0;
    uint32_t r_real_dim_cnt = 0;
    TensorUtils::GetRealDimCnt(tensor_desc, l_real_dim_cnt);
    TensorUtils::GetRealDimCnt(iter.second, r_real_dim_cnt);
    if ((tensor_desc.GetDataType() != iter.second.GetDataType()) ||
        (tensor_desc.GetOriginDataType() != iter.second.GetOriginDataType()) ||
        (tensor_desc.GetFormat() != iter.second.GetFormat()) ||
        (tensor_desc.GetOriginFormat() != iter.second.GetOriginFormat()) ||
        (tensor_desc.GetShape().ToString() != iter.second.GetShape().ToString()) ||
        (tensor_desc.GetOriginShape().ToString() != iter.second.GetOriginShape().ToString()) ||
        (l_real_dim_cnt != r_real_dim_cnt)) {
      GELOGW("The var tensor desc of variable[%s] in cache is different from VarManager.", iter.first.c_str());
      return false;
    }
  }
  return true;
}

bool ModelCacheHelper::IsVarAddrMgrMapSameAsCache(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return false;
  }
  // Compare variable address info between json and VarManager
  std::vector<std::pair<std::string, VarAddrMgr>> var_addr_mgr_vector;
  std::set<uint64_t> var_offset_set;
  auto ret = ParseVarAddrMgrMapFromJson(json, var_addr_mgr_vector, var_offset_set);
  if (ret != SUCCESS) {
    GELOGW("Fail to parse VarAddrMgrMap from Json.");
    return false;
  }
  for (const auto &iter : var_addr_mgr_vector) {
    uint8_t *dev_ptr = nullptr;
    rtMemType_t memory_type;
    ret = VarManager::Instance(session_id_)->GetVarAddr(iter.first, iter.second.tensor_desc, &dev_ptr, memory_type);
    if (ret != SUCCESS) {
      GELOGW("Fail to find tensor desc of var[%s].", iter.first.c_str());
      return false;
    }
    // Compare memory type and logic address
    if (iter.second.memory_type != memory_type || iter.second.address != dev_ptr) {
      GELOGW("The VarAddrMgr of variable[%s] in cache is different from VarManager.", iter.first.c_str());
      return false;
    }
  }
  return true;
}

bool ModelCacheHelper::IsBroadcastInfoSameAsCache(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return false;
  }
  // Compare broadcast info between json and VarManager
  std::unordered_map<std::string, VarBroadCastInfo> var_broadcast_info;
  auto ret = ParseBroadcastInfoFromJson(json, var_broadcast_info);
  if (ret != SUCCESS) {
    GELOGW("Fail to parse BroadcastInfo from Json.");
    return false;
  }
  for (const auto &iter : var_broadcast_info) {
    VarBroadCastInfo broadcast_info;
    if (VarManager::Instance(session_id_)->GetBroadCastInfo(graph_id_, iter.first, broadcast_info) != SUCCESS) {
      GELOGW("Fail to find broadcast info of var[%s].", iter.first.c_str());
      return false;
    }
    if (iter.second.var_name != broadcast_info.var_name || iter.second.idx != broadcast_info.idx ||
        iter.second.input_size != broadcast_info.input_size ||
        iter.second.input_offset != broadcast_info.input_offset ||
        iter.second.output_size != broadcast_info.output_size ||
        iter.second.output_offset != broadcast_info.output_offset) {
      GELOGW("The BroadcastInfo of variable[%s] in cache is different from VarManager.", iter.first.c_str());
      return false;
    }
  }
  return true;
}

bool ModelCacheHelper::IsTransRoadsSameAsCache(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return false;
  }
  // Compare trans road between json and VarManager
  std::unordered_map<std::string, std::vector<TransNodeInfo>> trans_roads;
  auto ret = ParseTransRoadsFromJson(json, trans_roads);
  if (ret != SUCCESS) {
    GELOGW("Fail to parse TransRoads from Json.");
    return false;
  }
  for (const auto &iter : trans_roads) {
    VarTransRoad *trans_road;
    trans_road = VarManager::Instance(session_id_)->GetTransRoad(iter.first);
    if (trans_road == nullptr) {
      GELOGW("Fail to find trans road of var[%s].", iter.first.c_str());
      return false;
    }
    if (trans_road->size() != iter.second.size()) {
      GELOGW("The TransRoad of variable[%s] in cache is different from VarManager.", iter.first.c_str());
      return false;
    }
    // Compare every trans node in trans road.
    for (size_t idx = 0; idx < trans_road->size(); idx += 1) {
      if (!(trans_road->at(idx).node_type == iter.second.at(idx).node_type &&
            trans_road->at(idx).input == iter.second.at(idx).input &&
            trans_road->at(idx).output == iter.second.at(idx).output)) {
        GELOGW("The TransRoad of variable[%s] in cache is different from VarManager.", iter.first.c_str());
        return false;
      }
    }
  }
  return true;
}

bool ModelCacheHelper::IsVarManagerParamSameAsCache(Json &json) const {
  if (!json.is_object()) {
    GELOGW("Input param json type should be object.");
    return false;
  }
  try {
    if (json[kSessionId].get<uint64_t>() != session_id_) {
      GELOGW("Check VarManager cache failed.[sessionId]");
      return false;
    }
    if (json[kDeviceId].get<uint32_t>() != VarManager::Instance(session_id_)->DeviceId()) {
      GELOGW("Check VarManager cache failed.[deviceId]");
      return false;
    }
    if (json[kJobId].get<uint64_t>() != VarManager::Instance(session_id_)->JobId()) {
      GELOGW("Check VarManager cache failed.[jobId]");
      return false;
    }
    if (json[kGraphMemMaxSize].get<size_t>() != VarManager::Instance(session_id_)->GetGraphMemoryMaxSize()) {
      GELOGW("Check VarManager cache failed.[graphMemMaxSize]");
      return false;
    }
    if (json[kVarMemMaxSize].get<size_t>() != VarManager::Instance(session_id_)->GetVarMemMaxSize()) {
      GELOGW("Check VarManager cache failed.[varMemMaxSize]");
      return false;
    }
    if (json[kVarMemLogicBase].get<size_t>() != VarManager::Instance(session_id_)->GetVarMemLogicBase()) {
      GELOGW("Check VarManager cache failed.[varMemLogicBase]");
      return false;
    }
    if (json[kUseMaxMemSize].get<size_t>() != VarManager::Instance(session_id_)->GetUseMaxMemorySize()) {
      GELOGW("Check VarManager cache failed.[useMaxMemSize]");
      return false;
    }
  } catch (const std::exception &e) {
    GELOGW("Fail to check VarManager json. Error message: %s", e.what());
    return false;
  }
  return true;
}

bool ModelCacheHelper::IsVarManagerSameAsCache(Json &json) const {
  if (!json.is_object()) {
    GELOGW("Input param json type should be object.");
    return false;
  }
  try {
    if (!IsVarManagerParamSameAsCache(json)) {
      GELOGW("Check VarManager cache failed.[Param]");
      return false;
    }
    Json mem_resource_json = move(json[kMemResourceMap]);
    auto ret = IsMemResourceSameAsCache(mem_resource_json);
    if (!ret) {
      GELOGW("Check VarManager cache failed.[MemResource]");
      return false;
    }
    Json var_resource_json = move(json[kVarResource]);
    ret = IsAllocatedGraphIdSameAsCache(var_resource_json[kAllocatedGraphId]);
    if (!ret) {
      GELOGW("Check VarManager cache failed.[AllocatedGraphId]");
      return false;
    }
    ret = IsChangedGraphIdSameAsCache(var_resource_json[kChangedGraphId]);
    if (!ret) {
      GELOGW("Check VarManager cache failed.[ChangedGraphId]");
      return false;
    }
    ret = IsBroadcastInfoSameAsCache(var_resource_json[kVarBroadcastInfo]);
    if (!ret) {
      GELOGW("Check VarManager cache failed.[VarBroadcastInfo]");
      return false;
    }
    ret = IsCurVarTensorDescSameAsCache(var_resource_json[kCurVarTensorDescMap]);
    if (!ret) {
      GELOGW("Check VarManager cache failed.[CurVarTensorDesc]");
      return false;
    }
    ret = IsVarAddrMgrMapSameAsCache(var_resource_json[kVarAddrMgrMap]);
    if (!ret) {
      GELOGW("Check VarManager cache failed.[VarAddrMgrMap]");
      return false;
    }
    ret = IsTransRoadsSameAsCache(var_resource_json[kTransRoads]);
    if (!ret) {
      GELOGW("Check VarManager cache failed.[TransRoads]");
      return false;
    }
  } catch (const std::exception &e) {
    GELOGW("Fail to check VarManager json. Error message: %s", e.what());
    return false;
  }
  return true;
}

Status ModelCacheHelper::RecoverMemResource(const Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  std::map<rtMemType_t, int64_t> var_mem_size;
  auto ret = ParseMemResourceFromJson(json, var_mem_size);
  if (ret != SUCCESS) {
    GELOGW("Fail to parse MemResource from Json.");
    return ret;
  }
  for (const auto &iter : var_mem_size) {
    ret = VarManager::Instance(session_id_)->UpdateVarMemSize(iter.first, iter.second);
    if (ret != SUCCESS) {
      GELOGW("Fail to recover var mem size.");
      return ret;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::RecoverAllocatedGraphId(const Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  std::map<std::string, uint32_t> allocated_graph_id;
  auto ret = ParseAllocatedGraphIdFromJson(json, allocated_graph_id);
  if (ret != SUCCESS) {
    GELOGW("Fail to parse AllocatedGraphId from Json.");
    return ret;
  }
  for (const auto &iter : allocated_graph_id) {
    ret = VarManager::Instance(session_id_)->SetAllocatedGraphId(iter.first, iter.second);
    if (ret != SUCCESS) {
      GELOGW("Fail to recover allocated graph id.");
      return ret;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::RecoverChangedGraphId(const Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  std::map<std::string, uint32_t> changed_graph_id;
  auto ret = ParseChangedGraphIdFromJson(json, changed_graph_id);
  if (ret != SUCCESS) {
    GELOGW("Fail to parse AllocatedGraphId from Json.");
    return ret;
  }
  for (const auto &iter : changed_graph_id) {
    ret = VarManager::Instance(session_id_)->SetChangedGraphId(iter.first, iter.second);
    if (ret != SUCCESS) {
      GELOGW("Fail to recover changed graph id.");
      return ret;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::RecoverVarAddrAndTensorDesc(const Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  std::vector<std::pair<std::string, VarAddrMgr>> var_addr_mgr_vector;
  std::set<uint64_t> var_offset_set;
  auto ret = ParseVarAddrMgrMapFromJson(json, var_addr_mgr_vector, var_offset_set);
  if (ret != SUCCESS) {
    GELOGW("Fail to parse VarAddrMgrMap from Json.");
    return ret;
  }
  for (const auto &iter : var_addr_mgr_vector) {
    const VarAddrMgr &tensor_addr_mgr = iter.second;
    const bool var_exist = VarManager::Instance(session_id_)->IsVarExist(iter.first, tensor_addr_mgr.tensor_desc);
    // SaveVarVddr if var does not exist, the logic address will be recorded by VarManager
    if (!var_exist) {
      auto logic_address = reinterpret_cast<uint64_t>(reinterpret_cast<uintptr_t>(tensor_addr_mgr.address));
      auto offset = (tensor_addr_mgr.offset);
      // Check logic address and offset
      if (logic_address - offset != VarManager::Instance(session_id_)->GetVarMemLogicBase()) {
        GELOGW("Check logic_address[%lu] and offset [%lu] of %s failed, var mem logic base is %lu, abandon",
               logic_address, offset, iter.first.c_str(), VarManager::Instance(session_id_)->GetVarMemLogicBase());
        return PARAM_INVALID;
      }
      // Offset is needed by SaveVarVddr instead of logic address
      ret = VarManager::Instance(session_id_)->SaveVarAddr(iter.first, tensor_addr_mgr.tensor_desc,
                reinterpret_cast<uint8_t *>(reinterpret_cast<uintptr_t>(offset)),
                tensor_addr_mgr.memory_type);
      if (ret != SUCCESS) {
        GELOGW("Fail to recover VarAddr or TensorDesc of var[%s].", iter.first.c_str());
        return ret;
      }
    }
    // SetVarAddr to update cur_var_tensor_desc_map_
    ret = VarManager::Instance(session_id_)
            ->SetVarAddr(iter.first, tensor_addr_mgr.tensor_desc, tensor_addr_mgr.address, tensor_addr_mgr.memory_type);
    if (ret != SUCCESS) {
      GELOGW("Fail to recover VarAddr or TensorDesc desc of var[%s].", iter.first.c_str());
      return ret;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::RecoverBroadcastInfo(const Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  std::unordered_map<std::string, VarBroadCastInfo> var_broadcast_info;
  auto ret = ParseBroadcastInfoFromJson(json, var_broadcast_info);
  if (ret != SUCCESS) {
    GELOGW("Fail to parse BroadcastInfo from Json.");
    return ret;
  }
  for (const auto &iter : var_broadcast_info) {
    VarBroadCastInfo broadcast_info;
    ret = VarManager::Instance(session_id_)->SaveBroadCastInfo(graph_id_, iter.second);
    if (ret != SUCCESS) {
      GELOGW("Fail to recover broadcast info of var[%s].", iter.first.c_str());
      return ret;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::RecoverTransRoads(const Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  std::unordered_map<std::string, std::vector<TransNodeInfo>> trans_roads;
  auto ret = ParseTransRoadsFromJson(json, trans_roads);
  if (ret != SUCCESS) {
    GELOGW("Fail to parse TransRoads from Json.");
    return ret;
  }
  for (const auto &iter : trans_roads) {
    ret = VarManager::Instance(session_id_)->SetTransRoad(iter.first, iter.second);
    if (ret != SUCCESS) {
      GELOGW("Fail to find trans road of var[%s].", iter.first.c_str());
      return ret;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::TensorDescToJson(const GeTensorDesc &ge_tensor_desc, Json &json) {
  if (!(json.is_null() || json.is_object())) {
    GELOGW("Input param json type should be null or object.");
    return PARAM_INVALID;
  }
  try {
    json[kDataType] = static_cast<int>(ge_tensor_desc.GetDataType());
    json[kOriginDataType] = static_cast<int>(ge_tensor_desc.GetOriginDataType());
    json[kLayout] = static_cast<int>(ge_tensor_desc.GetFormat());
    json[kOriginLayout] = static_cast<int>(ge_tensor_desc.GetOriginFormat());
    json[kShape] = ge_tensor_desc.GetShape().GetDims();
    json[kOriginShape] = ge_tensor_desc.GetOriginShape().GetDims();
    uint32_t real_dim_cnt = 0;
    (void)TensorUtils::GetRealDimCnt(ge_tensor_desc, real_dim_cnt);  // [No need to check value]
    json[kRealDimCnt] = real_dim_cnt;
  } catch (const std::exception &e) {
    GELOGW("Fail to trans GeTensorDesc to json. Error message: %s", e.what());
    return INTERNAL_ERROR;
  }
  return SUCCESS;
}

Status ModelCacheHelper::JsonToTensorDesc(const Json &json, ge::GeTensorDesc &ge_tensor_desc) {
  if (!json.is_object()) {
    GELOGW("Input param json type should be object.");
    return PARAM_INVALID;
  }
  try {
    ge_tensor_desc.SetDataType(static_cast<DataType>(json[kDataType].get<int>()));
    ge_tensor_desc.SetOriginDataType(static_cast<DataType>(json[kOriginDataType].get<int>()));
    ge_tensor_desc.SetFormat(static_cast<Format>(json[kLayout].get<int>()));
    ge_tensor_desc.SetOriginFormat(static_cast<Format>(json[kOriginLayout].get<int>()));
    GeShape shape(json[kShape].get<std::vector<int64_t>>());
    ge_tensor_desc.SetShape(shape);
    GeShape origin_shape(json[kOriginShape].get<std::vector<int64_t>>());
    ge_tensor_desc.SetOriginShape(origin_shape);
    auto real_dim_cnt = json[kRealDimCnt].get<uint32_t>();
    (void)TensorUtils::SetRealDimCnt(ge_tensor_desc, real_dim_cnt);  // [No need to check value]
  } catch (const std::exception &e) {
    GELOGW("Fail to trans Json to GeTensorDesc. Error message: %s", e.what());
    return INTERNAL_ERROR;
  }
  return SUCCESS;
}

Status ModelCacheHelper::GetNodesHashMapJson(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  map<std::string, size_t> hash_map;
  GetNodesHash(hash_map);
  for (const auto &iter : hash_map) {
    Json node_hash_json;
    try {
      node_hash_json[kName] = iter.first;
      node_hash_json[kHash] = iter.second;
      json.emplace_back(move(node_hash_json));
    } catch (const std::exception &e) {
      GELOGW("Fail to trans node cache to json. Error message: %s", e.what());
      return INTERNAL_ERROR;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::GetMemResourceMap(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  const auto total_size = VarManager::Instance(session_id_)->GetVarMemMaxSize();
  const auto var_mem_size = VarManager::Instance(session_id_)->GetVarMemSize(RT_MEMORY_HBM);
  Json mem_resource_json;
  try {
    mem_resource_json[kMemType] = RT_MEMORY_HBM;
    mem_resource_json[kTotalSize] = total_size;
    mem_resource_json[kVarMemSize] = var_mem_size;
    json.emplace_back(move(mem_resource_json));
  } catch (const std::exception &e) {
    GELOGW("Fail to trans MemResourceMap to json. Error message: %s", e.what());
    return INTERNAL_ERROR;
  }
  return SUCCESS;
}

Status ModelCacheHelper::GetVarAddrMgrMapJson(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  std::unordered_map<std::string, VarAddrMgr> var_addr_mgr_map;
  VarManager::Instance(session_id_)->GetAllVarAddrMgr(var_addr_mgr_map);
  try {
    for (const auto &iter : var_addr_mgr_map) {
      Json var_addr_json;
      string name;
      GetVarNameFromVarKey(iter.first, iter.second.tensor_desc, name);
      var_addr_json[kName] = name;
      var_addr_json[kAddress] = static_cast<uint64_t>(reinterpret_cast<uintptr_t>(iter.second.address));
      var_addr_json[kMemoryType] = iter.second.memory_type;
      var_addr_json[kOffset] = iter.second.offset;

      // Copy tensor desc to json.
      Json tensor_desc_json;
      auto ret = TensorDescToJson(iter.second.tensor_desc, tensor_desc_json);
      if (ret != SUCCESS) {
        GELOGW("Fail to trans tensor desc to json.");
        return INTERNAL_ERROR;
      }
      var_addr_json[kTensorDesc] = move(tensor_desc_json);

      json.emplace_back(move(var_addr_json));
    }
  } catch (const std::exception &e) {
    GELOGW("Fail to trans VarAddrMgrMap to json. Error message: %s", e.what());
    return INTERNAL_ERROR;
  }
  return SUCCESS;
}

Status ModelCacheHelper::GetCurVarTensorDescMapJson(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  try {
    for (const auto &name : var_names_) {
      Json cur_tensor_desc_json;
      GeTensorDesc tensor_desc;
      auto ret = VarManager::Instance(session_id_)->GetCurVarDesc(name, tensor_desc);
      if (ret != SUCCESS) {
        GELOGI("Get variable[%s] current tensor desc failed. It will be skipped.", name.c_str());
        continue;
      }
      cur_tensor_desc_json[kName] = name;

      Json tensor_desc_json;
      ret = TensorDescToJson(tensor_desc, tensor_desc_json);
      if (ret != SUCCESS) {
        GELOGW("Fail to trans tensor desc to json.");
        return INTERNAL_ERROR;
      }
      cur_tensor_desc_json[kTensorDesc] = move(tensor_desc_json);
      json.emplace_back(move(cur_tensor_desc_json));
    }
  } catch (const std::exception &e) {
    GELOGW("Fail to trans CurVarTensorDescMap to json. Error message: %s", e.what());
    return INTERNAL_ERROR;
  }
  return SUCCESS;
}

Status ModelCacheHelper::GetTransRoadsJson(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  try {
    for (const auto &name : var_names_) {
      auto trans_road = VarManager::Instance(session_id_)->GetTransRoad(name);
      if (trans_road == nullptr) {
        continue;
      }
      // Json object, variable name and trans road
      Json trans_road_map_json;
      trans_road_map_json[kName] = name;

      Json trans_road_json;
      Status ret;
      // Add nodes' info to json
      for (const auto &trans_node_info : *trans_road) {
        Json trans_node_info_json;
        trans_node_info_json[kNodeType] = trans_node_info.node_type;
        Json input_tensor_desc_json;
        ret = TensorDescToJson(trans_node_info.input, input_tensor_desc_json);
        if (ret != SUCCESS) {
          GELOGW("Fail to trans tensor desc to json.");
          return INTERNAL_ERROR;
        }
        trans_node_info_json[kInputTensorDesc] = move(input_tensor_desc_json);
        Json output_tensor_desc_json;
        ret = TensorDescToJson(trans_node_info.output, output_tensor_desc_json);
        if (ret != SUCCESS) {
          GELOGW("Fail to trans tensor desc to json.");
          return INTERNAL_ERROR;
        }
        trans_node_info_json[kOutputTensorDesc] = move(output_tensor_desc_json);
        trans_road_json.emplace_back(move(trans_node_info_json));
      }
      trans_road_map_json[kTransRoad] = move(trans_road_json);
      json.emplace_back(move(trans_road_map_json));
    }
  } catch (const std::exception &e) {
    GELOGW("Fail to trans VarToTransRoad to json. Error message: %s", e.what());
    return INTERNAL_ERROR;
  }
  return SUCCESS;
}

Status ModelCacheHelper::GetChangedGraphIdJson(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  for (const auto &name : var_names_) {
    uint32_t changed_graph_id = 0;
    Status ret = VarManager::Instance(session_id_)->GetChangedGraphId(name, changed_graph_id);
    if (ret != SUCCESS) {
      continue;
    }
    Json name_and_changed_graph_id;
    try {
      name_and_changed_graph_id[kName] = name;
      name_and_changed_graph_id[kGraphId] = changed_graph_id;
      json.emplace_back(move(name_and_changed_graph_id));
    } catch (const std::exception &e) {
      GELOGW("Fail to trans ChangedGraphId to json. Error message: %s", e.what());
      return INTERNAL_ERROR;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::GetAllocatedGraphIdJson(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  for (const auto &name : var_names_) {
    uint32_t allocated_graph_id = 0;
    Status ret = VarManager::Instance(session_id_)->GetAllocatedGraphId(name, allocated_graph_id);
    if (ret != SUCCESS) {
      continue;
    }
    Json name_and_allocated_graph_id;
    try {
      name_and_allocated_graph_id[kName] = name;
      name_and_allocated_graph_id[kGraphId] = allocated_graph_id;
      json.emplace_back(move(name_and_allocated_graph_id));
    } catch (const std::exception &e) {
      GELOGW("Fail to trans AllocatedGraphId to json. Error message: %s", e.what());
      return INTERNAL_ERROR;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::GetBroadcastInfoJson(Json &json) const {
  if (!(json.is_null() || json.is_array())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  for (const auto &name : var_names_) {
    VarBroadCastInfo var_broadcast_info;
    Status ret = VarManager::Instance(session_id_)->GetBroadCastInfo(graph_id_, name, var_broadcast_info);
    if (ret != SUCCESS) {
      continue;
    }
    Json var_broadcast_info_json;
    try {
      var_broadcast_info_json[kName] = name;
      var_broadcast_info_json[kBroadcastName] = var_broadcast_info.broadcast_name;
      var_broadcast_info_json[kIdx] = var_broadcast_info.idx;
      var_broadcast_info_json[kInputOffset] = var_broadcast_info.input_offset;
      var_broadcast_info_json[kInputSize] = var_broadcast_info.input_size;
      var_broadcast_info_json[kOutputOffset] = var_broadcast_info.output_offset;
      var_broadcast_info_json[kOutputSize] = var_broadcast_info.output_size;
      json.emplace_back(move(var_broadcast_info_json));
    } catch (const std::exception &e) {
      GELOGW("Fail to trans VarBroadcastInfo to json. Error message: %s", e.what());
      return INTERNAL_ERROR;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::GetVarResourceJson(Json &json) const {
  if (!(json.is_null() || json.is_object())) {
    GELOGW("Input param json type should be null or object.");
    return PARAM_INVALID;
  }
  Json var_addr_mgr_map_json;
  Status ret = GetVarAddrMgrMapJson(var_addr_mgr_map_json);
  if (ret != SUCCESS) {
    GELOGW("GetVarAddrMgrMapJson failed.");
    return INTERNAL_ERROR;
  }

  Json cur_var_tensor_desc_map_json;
  ret = GetCurVarTensorDescMapJson(cur_var_tensor_desc_map_json);
  if (ret != SUCCESS) {
    GELOGW("GetCurVarTensorDescMapJson failed.");
    return INTERNAL_ERROR;
  }

  Json trans_roads_json;
  ret = GetTransRoadsJson(trans_roads_json);
  if (ret != SUCCESS) {
    GELOGW("GetTransRoadsJson failed.");
    return INTERNAL_ERROR;
  }

  Json changed_graph_id_json;
  ret = GetChangedGraphIdJson(changed_graph_id_json);
  if (ret != SUCCESS) {
    GELOGW("GetChangedGraphIdJson failed.");
    return INTERNAL_ERROR;
  }

  Json allocated_graph_id_json;
  ret = GetAllocatedGraphIdJson(allocated_graph_id_json);
  if (ret != SUCCESS) {
    GELOGW("GetAllocatedGraphIdJson failed.");
    return INTERNAL_ERROR;
  }

  Json var_broadcast_info_json;
  ret = GetBroadcastInfoJson(var_broadcast_info_json);
  if (ret != SUCCESS) {
    GELOGW("GetBroadcastInfoJson failed.");
    return INTERNAL_ERROR;
  }

  try {
    json[kVarAddrMgrMap] = move(var_addr_mgr_map_json);
    json[kCurVarTensorDescMap] = move(cur_var_tensor_desc_map_json);
    json[kTransRoads] = move(trans_roads_json);
    json[kChangedGraphId] = move(changed_graph_id_json);
    json[kAllocatedGraphId] = move(allocated_graph_id_json);
    json[kVarBroadcastInfo] = move(var_broadcast_info_json);
  } catch (const exception &e) {
    GELOGW("Fail to generate VarResource json. Error message: %s", e.what());
    return INTERNAL_ERROR;
  }
  return SUCCESS;
}

Status ModelCacheHelper::GetVarManagerJson(Json &json) const {
  if (!(json.is_null() || json.is_object())) {
    GELOGW("Input param json type should be null or object.");
    return PARAM_INVALID;
  }

  Json mem_resource_map_json;
  auto ret = GetMemResourceMap(mem_resource_map_json);
  if (ret != SUCCESS) {
    GELOGW("GetMemResourceMap failed.");
    return INTERNAL_ERROR;
  }

  Json var_resource_json;
  ret = GetVarResourceJson(var_resource_json);
  if (ret != SUCCESS) {
    GELOGW("GetVarResourceJson failed.");
    return INTERNAL_ERROR;
  }

  try {
    json[kSessionId] = session_id_;
    json[kDeviceId] = VarManager::Instance(session_id_)->DeviceId();
    json[kJobId] = VarManager::Instance(session_id_)->JobId();
    json[kGraphMemMaxSize] = VarManager::Instance(session_id_)->GetGraphMemoryMaxSize();
    json[kVarMemMaxSize] = VarManager::Instance(session_id_)->GetVarMemMaxSize();
    json[kVarMemLogicBase] = VarManager::Instance(session_id_)->GetVarMemLogicBase();
    json[kUseMaxMemSize] = VarManager::Instance(session_id_)->GetUseMaxMemorySize();
    json[kMemResourceMap] = move(mem_resource_map_json);
    json[kVarResource] = move(var_resource_json);
  } catch (const exception &e) {
    GELOGW("Fail to generate VarManager json. Error message: %s", e.what());
    return INTERNAL_ERROR;
  }
  return SUCCESS;
}

Status ModelCacheHelper::SaveVarManagerToCache(bool before_build) const {
  if (!is_cache_path_valid_for_output) {
    GELOGW("Invalid cache path.");
    return FAILED;
  }
  Json var_manager_json;
  auto ret = GetVarManagerJson(var_manager_json);
  if (ret != SUCCESS) {
    GELOGW("Fail to generate VarManager json.");
    return FAILED;
  }
  string var_manager_path = to_string(graph_id_) + "_" + to_string(graph_id_run_times_[graph_id_]) +
                            (before_build ? kBeforeVarManagerSuffix : kAfterVarManagerSuffix);
  ret = SaveJsonToFile(var_manager_path, var_manager_json);
  if (ret != SUCCESS) {
    GELOGW("Fail to save VarManager info to json file, path: %s.", cache_path_.c_str());
    return ret;
  }
  return SUCCESS;
}

Status ModelCacheHelper::SaveOmModelToCache(const GeModelPtr &ge_model) const {
  if (!is_cache_path_valid_for_output) {
    GELOGW("Invalid cache path.");
    return FAILED;
  }
  string om_path = RealPath(cache_path_.c_str());
  if (om_path.empty()) {
    GELOGW("file path is invalid. please check path om: %s", cache_path_.c_str());
    return FAILED;
  }
  string cache_om_path = cache_path_;
  cache_om_path += (to_string(graph_id_) + "_" + to_string(graph_id_run_times_[graph_id_]) + kOmSuffix);
  GELOGI("SaveOmModelToCache: start to save om model : %s", cache_om_path.c_str());
  ModelHelper model_helper;
  SaveParam save_param;
  ModelBufferData model;
  Status ret = model_helper.SaveToOmModel(ge_model, save_param, cache_om_path, model);
  if (ret != SUCCESS) {
    GELOGW("SaveOmModelToCache: save mode failed. ret = %u", ret);
    return ret;
  }
  return SUCCESS;
}

Status ModelCacheHelper::ParseMemResourceFromJson(const Json &json, map<rtMemType_t, int64_t> &mem_resource) {
  if (!(json.is_array() || json.is_null())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  mem_resource.clear();
  for (const Json &mem_resource_json : json) {
    try {
      rtMemType_t mem_type = mem_resource_json[kMemType].get<rtMemType_t>();
      uint64_t var_mem_size = mem_resource_json[kVarMemSize].get<int64_t>();
      mem_resource[mem_type] = var_mem_size;
    } catch (const exception &e) {
      GELOGW("Fail to trans Json to MemResource. Error message: %s", e.what());
      return INTERNAL_ERROR;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::ParseVarAddrMgrMapFromJson(
  const Json &json, std::vector<std::pair<std::string, VarAddrMgr>> &var_addr_mgr_vector,
  std::set<uint64_t> &var_offset_set) {
  if (!(json.is_array() || json.is_null())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  var_addr_mgr_vector.clear();
  var_offset_set.clear();
  for (const Json &var_addr_json : json) {
    VarAddrMgr var_addr_mgr;
    try {
      auto logic_address = var_addr_json[kAddress].get<uint64_t>();
      auto address = reinterpret_cast<uint8_t *>(reinterpret_cast<uintptr_t>(logic_address));
      var_addr_mgr.address = address;
      var_addr_mgr.offset = var_addr_json[kOffset].get<uint64_t>();
      var_addr_mgr.memory_type = var_addr_json[kMemoryType].get<rtMemType_t>();
      auto ret = JsonToTensorDesc(var_addr_json[kTensorDesc], var_addr_mgr.tensor_desc);
      if (ret != SUCCESS) {
        GELOGW("Fail to trans json to tensor desc.");
        return ret;
      }
      var_addr_mgr_vector.emplace_back(var_addr_json[kName].get<string>(), move(var_addr_mgr));
      var_offset_set.insert(logic_address);
    } catch (const exception &e) {
      GELOGW("Fail to trans Json to VarAddrMgr. Error message: %s", e.what());
      return INTERNAL_ERROR;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::ParseCurVarTensorDescMapFromJson(
  const Json &json, std::unordered_map<std::string, ge::GeTensorDesc> &cur_var_tensor_desc_map) {
  if (!(json.is_array() || json.is_null())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  cur_var_tensor_desc_map.clear();
  for (const Json &tensor_desc_json : json) {
    GeTensorDesc tensor_desc;
    try {
      auto ret = JsonToTensorDesc(tensor_desc_json[kTensorDesc], tensor_desc);
      if (ret != SUCCESS) {
        GELOGW("Fail to trans json to tensor desc.");
        return ret;
      }
      cur_var_tensor_desc_map[tensor_desc_json[kName].get<string>()] = move(tensor_desc);
    } catch (const exception &e) {
      GELOGW("Fail to trans Json to VarAddrMgr. Error message: %s", e.what());
      return INTERNAL_ERROR;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::ParseTransRoadsFromJson(
  const Json &json, std::unordered_map<std::string, std::vector<TransNodeInfo>> &trans_roads) {
  if (!(json.is_array() || json.is_null())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  trans_roads.clear();
  try {
    for (const Json &name_trans_road_json : json) {
      const Json &trans_road_json = name_trans_road_json[kTransRoad];
      if (!(trans_road_json.is_array() || trans_road_json.is_null())) {
        GELOGW("%s json type should be null or object.", kTransRoad);
        return PARAM_INVALID;
      }
      vector<TransNodeInfo> trans_road;
      for (const Json &trans_node_json : trans_road_json) {
        TransNodeInfo trans_node_info;
        trans_node_info.node_type = trans_node_json[kNodeType];
        GeTensorDesc input_tensor_desc;
        auto ret = JsonToTensorDesc(trans_node_json[kInputTensorDesc], input_tensor_desc);
        if (ret != SUCCESS) {
          GELOGW("Fail to trans json to tensor desc.");
          return ret;
        }
        trans_node_info.input = move(input_tensor_desc);
        GeTensorDesc output_tensor_desc;
        ret = JsonToTensorDesc(trans_node_json[kOutputTensorDesc], output_tensor_desc);
        if (ret != SUCCESS) {
          GELOGW("Fail to trans json to tensor desc.");
          return ret;
        }
        trans_node_info.output = move(output_tensor_desc);
        trans_road.emplace_back(move(trans_node_info));
      }
      trans_roads[name_trans_road_json[kName].get<string>()] = move(trans_road);
    }
  } catch (const exception &e) {
    GELOGW("Fail to trans Json to TransRoads. Error message: %s", e.what());
    return INTERNAL_ERROR;
  }
  return SUCCESS;
}

Status ModelCacheHelper::ParseChangedGraphIdFromJson(const Json &json,
                                                     std::map<std::string, uint32_t> &changed_graph_id) {
  if (!(json.is_array() || json.is_null())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  changed_graph_id.clear();
  for (const Json &name_graph_id_json : json) {
    try {
      changed_graph_id[name_graph_id_json[kName].get<string>()] = name_graph_id_json[kGraphId].get<uint32_t>();
    } catch (const exception &e) {
      GELOGW("Fail to trans Json to changed graph id. Error message: %s", e.what());
      return INTERNAL_ERROR;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::ParseAllocatedGraphIdFromJson(const Json &json,
                                                       std::map<std::string, uint32_t> &allocated_graph_id) {
  if (!(json.is_array() || json.is_null())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  allocated_graph_id.clear();
  for (const Json &name_graph_id_json : json) {
    try {
      allocated_graph_id[name_graph_id_json[kName].get<string>()] = name_graph_id_json[kGraphId].get<uint32_t>();
    } catch (const exception &e) {
      GELOGW("Fail to trans Json to allocated graph id. Error message: %s", e.what());
      return INTERNAL_ERROR;
    }
  }
  return SUCCESS;
}

Status ModelCacheHelper::ParseBroadcastInfoFromJson(
  const Json &json, std::unordered_map<std::string, VarBroadCastInfo> &var_broadcast_info) {
  if (!(json.is_array() || json.is_null())) {
    GELOGW("Input param json type should be null or array.");
    return PARAM_INVALID;
  }
  for (const Json &broadcast_info_json : json) {
    VarBroadCastInfo broadcast_info;
    try {
      broadcast_info.var_name = broadcast_info_json[kName].get<string>();
      broadcast_info.broadcast_name = broadcast_info_json[kBroadcastName].get<string>();
      broadcast_info.idx = broadcast_info_json[kIdx].get<int>();
      broadcast_info.input_offset = broadcast_info_json[kInputOffset].get<int64_t>();
      broadcast_info.input_size = broadcast_info_json[kInputSize].get<uint64_t>();
      broadcast_info.output_offset = broadcast_info_json[kOutputOffset].get<int64_t>();
      broadcast_info.output_size = broadcast_info_json[kOutputSize].get<uint64_t>();
    } catch (const exception &e) {
      GELOGW("Fail to trans Json to VarBroadCastInfo. Error message: %s", e.what());
      return INTERNAL_ERROR;
    }
    var_broadcast_info[broadcast_info.var_name] = broadcast_info;
  }
  return SUCCESS;
}

Status ModelCacheHelper::LoadOmModelFromCache(GeModelPtr &ge_model) const {
  string cache_om = cache_path_ + to_string(graph_id_) + "_" + to_string(graph_id_run_times_[graph_id_]) + kOmSuffix;
  if (!CheckInputPathValid(cache_om)) {
    GELOGW("Invalid cache path for input:%s.", cache_om.c_str());
    return FAILED;
  }
  string om_path = RealPath(cache_om.c_str());
  if (om_path.empty()) {
    GELOGW("file path is invalid. please check file om: %s", om_path.c_str());
    return FAILED;
  }
  GELOGI("load model data from file: %s", om_path.c_str());
  Status ret;
  string key_path;
  int32_t priority = 0;
  ModelData model_data;
  ret = ModelParserBase::LoadFromFile(om_path.c_str(), key_path.c_str(), priority, model_data);
  if (ret != SUCCESS) {
    GELOGW("LoadOmModelFromCache: Load model from file failed. ret = %u", ret);
    return ret;
  }

  ModelHelper model_helper;
  ret = model_helper.LoadModel(model_data);
  if (ret != SUCCESS) {
    GELOGW("LoadOmModelFromCache: Load model from data failed. ret = %u", ret);
    return ret;
  }
  ge_model = model_helper.GetGeModel();
  ret = RecompileNodes(ge_model);
  if (ret != SUCCESS) {
    GELOGW("LoadOmModelFromCache: recompile nodes failed. ret = %u", ret);
    return ret;
  }
  return SUCCESS;
}

Status ModelCacheHelper::GetVarNameFromVarKey(const string &var_key, const GeTensorDesc &tensor_desc,
                                              string &var_name) {
  std::string::size_type underline_idx = var_key.rfind('_');
  if (underline_idx == std::string::npos) {
    GELOGW("Invalid var key: underline not found");
    return FAILED;
  }
  std::string::size_type format_idx =
    var_key.rfind(std::to_string(static_cast<int32_t>(tensor_desc.GetFormat())), underline_idx);
  if (format_idx == std::string::npos) {
    GELOGW("Invalid var key: format not found");
    return FAILED;
  }
  var_name = var_key.substr(0, format_idx);
  return SUCCESS;
}
}  // namespace ge