Method CachedLookup

tensorflow/python/util/util.cc:146–186

Caches successful executions of the one-argument (PyObject*) callable "ternary_predicate" based on the type of "o". -1 from the callable indicates an unsuccessful check (not cached), 0 indicates that "o"'s type does not match the predicate, and 1 indicates that it does. Used to avoid calling back into Python for expensive isinstance checks.

  // does not match the predicate, and 1 indicates that it does. Used to avoid
  // calling back into Python for expensive isinstance checks.
  int CachedLookup(PyObject* o) {
    // Try not to return to Python - see if the type has already been seen
    // before.

    auto* type = Py_TYPE(o);

    {
      tf_shared_lock l(type_to_sequence_map_mu_);
      auto it = type_to_sequence_map_.find(type);
      if (it != type_to_sequence_map_.end()) {
        return it->second;
      }
    }

    int check_result = ternary_predicate_(o);

    if (check_result == -1) {
      return -1;  // Type check error, not cached.
    }

    // NOTE: This is never decref'd as long as the object lives, which is likely
    // forever, but we don't want the type to get deleted as long as it is in
    // the map. This should not be too much of a leak, as there should only be a
    // relatively small number of types in the map, and an even smaller number
    // that are eligible for decref. As a precaution, we limit the size of the
    // map to 1024.
    {
      mutex_lock l(type_to_sequence_map_mu_);
      if (type_to_sequence_map_.size() < kMaxItemsInCache) {
        Py_INCREF(type);
        auto insert_result = type_to_sequence_map_.insert({type, check_result});
        if (!insert_result.second) {
          // The type was added to the cache by a concurrent thread after we
          // looked it up above.
          Py_DECREF(type);
        }
      }
    }

    return check_result;
  }

 private:
  std::function<int(PyObject*)> ternary_predicate_;