Method CompileImpl

tensorflow/compiler/jit/xla_compilation_cache.cc:345–489

}

Status XlaCompilationCache::CompileImpl(
    const XlaCompiler::Options& options, const NameAttrList& function,
    std::vector<XlaCompiler::Argument>& args,
    const std::function<Status(XlaCompiler* compiler,
                               const std::vector<XlaCompiler::Argument>& args,
                               XlaCompiler::CompilationResult*)>& compile_fn,
    CompileMode compile_mode,
    const XlaCompiler::CompilationResult** out_compilation_result,
    xla::LocalExecutable** out_executable) {
  DCHECK_NE(out_executable, nullptr);
  VLOG(2) << "XlaCompilationCache::Compile " << DebugString();

  VLOG(2) << "num_inputs=" << args.size();
  if (VLOG_IS_ON(3)) {
    for (int i = 0; i < args.size(); i++) {
      VLOG(3) << i << ": " << args[i].HumanString();
    }
  }
  absl::optional<int64> compile_threshold;
  if (compile_mode == CompileMode::kLazy) {
    compile_threshold = kDefaultCompilationThreshold;
  } else if (compile_mode == CompileMode::kAsync) {
    compile_threshold = 0; // for now, always compile right away
  }

  TF_ASSIGN_OR_RETURN(Signature signature, BuildSignature(function, args));
  string function_name = function.name();
  string human_signature = VLOG_IS_ON(3) ? signature.HumanString() : function_name;
  VLOG(2) << "Signature: " << human_signature;

  // The outer lock protects the existence of the cache entry. It does not
  // protect the contents of the cache entry.
  Entry* entry;
  {
    mutex_lock lock(compile_cache_mu_);
    // Find or create a cache entry.
    std::unique_ptr<Entry>& e = cache_[signature];
    if (!e) {
      e.reset(new Entry);
    }
    entry = e.get();
  }

  // We avoid compiling clusters that have "gone megamorphic" i.e. have an
  // excessive amount of shape dynamism.
  bool is_megamorphic;

  {
    mutex_lock lock(cluster_compile_stats_mu_);
    auto it =
        cluster_compile_stats_.emplace(function_name, ClusterCompileStats{})
            .first;

    it->second.execution_count++;
    // The is_megamorphic bit is "sticky".  We assume clusters that have been
    // observed to be megamorphic once stay megamorphic forever.
    it->second.is_megamorphic |=
        IsMegamorphic(/*compile_count=*/it->second.compile_count,