// CHECK:      %[[READ0:.*]] = "tf.ReadVariableOp"(%arg0)
  // CHECK-NEXT: %[[READ2:.*]] = "tf.ReadVariableOp"(%arg2)
  // CHECK-NEXT: tf_device.replicate
  // CHECK-NEXT:   %[[READ1:.*]] = "tf.ReadVariableOp"(%arg1)
  // CHECK-NEXT:   "tf.OpA"(%[[READ0]], %[[READ1]], %[[READ2]])
  tf_device.replicate {n = 2 : i32} {

    %key, %key_control = tf_executor.island wraps "tf.GetKey"() : () -> !tf_str
    // CHECK: "tf.ReadVariableOp"(%arg0)
    %read1, %read1_control  = tf_executor.island wraps "tf.ReadVariableOp"(%arg0) : (!tf_res) -> tensor<f32>
    // CHECK: "tf.ReadVariableOp"(%arg1)
    %read2, %read2_control  = tf_executor.island wraps "tf.ReadVariableOp"(%arg1) : (!tf_res) -> tensor<f32>

type status int

const (
	Pending status = iota
	Ready
	Stopped
)

// ready is a three state condition variable that blocks until is Ready if is not Stopped.
// Its initial state is Pending and its state machine diagram is as follow.
//
// Pending <------> Ready -----> Stopped
//
//	|                           ^
//	└---------------------------┘
type ready struct {

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build ignore

// This is a test program that verifies that it can read from
// descriptor 3 and that no other descriptors are open.
// This is not done via TestHelperProcess and GO_EXEC_TEST_PID
// because we want to ensure that this program does not use cgo,

        ports:
        - containerPort: 15090
          name: http-envoy-prom
          protocol: TCP
        readinessProbe:
          failureThreshold: 4
          httpGet:
            path: /healthz/ready
            port: 15021
          periodSeconds: 15
          timeoutSeconds: 3
        resources:
          limits:
            cpu: "2"
            memory: 1Gi
          requests:

            # But we don't need _everything_ in `privileged`, so drop+readd capabilities based on feature.
            # privileged is redundant with CAP_SYS_ADMIN
            # since it's redundant, hardcode it to `true`, then manually drop ALL + readd granular
            # capabilities we actually require
            capabilities:
              drop:
              - ALL

// RUN: tf-opt -tf-tpu-resource-read-for-write %s | FileCheck %s --dump-input=always

// CHECK-LABEL: func @write_only_resource
// CHECK-SAME: ([[ARG0:%.*]]: tensor<i32>, [[ARG1:%.*]]: tensor<f32>, [[ARG2:%.*]]: tensor<*x!tf_type.resource<tensor<i32>>>)
func.func @write_only_resource(%arg0: tensor<i32>, %arg1: tensor<f32>, %arg2: tensor<*x!tf_type.resource<tensor<i32>>>) {
  // CHECK-NEXT: [[READ:%.*]] = "tf.ReadVariableOp"([[ARG2]])

    /**
     * Reads a nullable string value. Can reads any value that was written using {@link Encoder#writeNullableString(CharSequence)}.
     *
     * @throws EOFException when the end of the byte stream is reached before the string can be fully read.
     */
    @Nullable
    String readNullableString() throws EOFException, IOException;

    /**

  for (Operation& op : replicate.getBody().front()) {
    if (auto read = llvm::dyn_cast<ReadVariableOp>(&op)) {
      bool is_cpu_read;
      if (failed(IsCpuRead(func, read, is_cpu_read))) return failure();
      if (is_cpu_read) reads.push_back(read);
    }
  }
  return success();
}

// Move reads above the `replicate`. Skip reads that come after a write to the
// same resource.

Regular Reads will block until data is available, but not wait for a full buffer. 
Writes will block until there is space available and writes bigger than the buffer will wait for reads to make space.

`TryRead` and `TryWrite` are still available for non-blocking reads and writes.