bool read_only) {
  VLOG(4) << "    Updating access for resource " << resource_id;
  op_to_resource_ids_[op].push_back({resource_id, read_only});

  // For unknown ID case, first update access info for all other resource IDs.
  if (resource_id == kUnknownResourceId) {
    if (read_only) {
      // New unknown read is not tracked by any other access.

    setDefault(int.class, 32);
    setDefault(String.class, "abcd");
    setDefault(Method.class, AbstractPackageSanityTests.class.getDeclaredMethods()[0]);
    setDefault(MapMode.class, MapMode.READ_ONLY);
    setDefault(CharsetEncoder.class, Charsets.UTF_8.newEncoder());
  }

    setDefault(int.class, 32);
    setDefault(String.class, "abcd");
    setDefault(Method.class, AbstractPackageSanityTests.class.getDeclaredMethods()[0]);
    setDefault(MapMode.class, MapMode.READ_ONLY);
    setDefault(CharsetEncoder.class, Charsets.UTF_8.newEncoder());
  }

  // by this thread.
  bool shared_lock_held() const { return shared_lock_held_; }
  void set_shared_lock_held() { shared_lock_held_ = true; }

  bool read_only() const { return read_only_; }
  void set_read_only() { read_only_ = true; }

  const std::optional<ManagedStackTrace>& definition_stack_trace() const {
    return definition_stack_trace_;
  }

  ~VariableInfo();

 private:
  int index_;

                                bool read_only);

  // Updates resource access for given `resource_id` and `op` in
  // `per_resource_access_info_` and `op_to_resource_ids_`.
  void UpdateAccess(ResourceId resource_id, Operation* op, bool read_only);

  // Returns true iff the last unknown resource access is already indirectly
  // tracked by a previous `resource` access. `read_only` specifies the type of
  // access considered.

    written_resources_.remove(resource);
  }

  // Replaces all resource loads in all regions attached to the op.
  void ReplaceResourceLoads(bool read_only) {
    llvm::for_each(op_->getRegions(), [&](Region& region) {
      ReplaceResourceLoads(region, read_only);
    });
  }

  static LogicalResult ReplaceOpWithNewOp(Operation* op);

 private:
  // Returns if any resources need lifting.

                               const ResourceIdVec& other_resource_ids) {
  for (const auto& [resource_id, read_only] : resource_ids) {
    for (const auto& [other_resource_id, other_read_only] :
         other_resource_ids) {
      if (IsPotentiallySameResource(resource_id, other_resource_id) &&
          !(read_only && other_read_only)) {
        return true;
      }
    }
  }
  return false;
}

        executer.withGradleUserHomeDir(new File("/gradle-home"))
    }

    GradleInContainer bindReadOnly(File local, String containerPath) {
        container.addFileSystemBind(local.absolutePath, containerPath, BindMode.READ_ONLY, SelinuxContext.NONE)
        this
    }

    GradleInContainer bindWritable(File local, String containerPath) {

//
// `variables` is allowed to contain instances that don't track a resource
// variable (i.e. variables[i].var() can be null for some i).
//
// If the variable is read_only(), only acquires reader locks.
Status LockVariables(absl::Span<VariableInfo*> variables)
    TF_EXCLUSIVE_LOCK_FUNCTION();
Status LockVariables(absl::Span<VariableInfo> variables)
    TF_EXCLUSIVE_LOCK_FUNCTION();

      // objects are destroyed.
      // TODO(b/128495870) Add support for passing aliased resource variables.
      return errors::Unimplemented("Duplicate variable passed to XLA cluster");
    }
    if (variables[i]->read_only()) {
      VLOG(4) << "Acquiring reader lock for variable "
              << reinterpret_cast<void*>(variable);
      mu->lock_shared();
      variables[i]->set_shared_lock_held();
    } else {