limitations under the License.
*/

package stateful

import (
	"context"
	"fmt"
	"sync"

	v1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/klog/v2"
	"k8s.io/kubernetes/pkg/scheduler/framework"
)

// MultipointExample is an example plugin that is executed at multiple extension points.
// This plugin is stateful. It receives arguments at initialization (NewMultipointPlugin)

}

# Find PartitionedCall ops in main and match the callee name.
# CHECK: func @main
# CHECK: "tf.PartitionedCall"
# CHECK-SAME: f = @[[FUNCTION_FOO:[a-zA-Z0-9_]*]]

# Find callee and verify it has the stateful attribute set.
# CHECK: func private @[[FUNCTION_FOO]]
# CHECK-SAME: attributes

    .Attr("Nresources: int >= 0")
    .Output("results: Tresults")
    .Attr("Tresults: list(type) >= 0")
    .Attr("function: func")
    // XLA random-number generation ops are stateful.
    // TODO(phawkins): create stateful and non-stateful variants of XlaLaunch.
    .SetIsStateful()
    .Doc("XLA Launch Op. For use by the XLA JIT only.");

REGISTER_OP("XlaLaunchV2")
    .Input("args: Targs")
    .Output("results: Tresults")

        def serializer = Mock(Serializer)
        def decoder = Mock(Decoder)
        def encoder = Mock(Encoder)

        given:
        def stateful = Serializers.stateful(serializer)
        def reader = stateful.newReader(decoder)
        def writer = stateful.newWriter(encoder)

        when:
        def result1 = reader.read()
        def result2 = reader.read()

        then:
        result1 == "one"

// TFL op interface for stateful operands.

def TFL_StatefulOp : OpInterface<"StatefulOpInterface"> {
  let description = [{
    Interface for ops that are stateful and need to identify stateful operands.

    Stateful operands correspond to TF's variables semantics. An op that has 1
    or more stateful operands is a stateful op.
  }];

  let methods = [
    InterfaceMethod<

         */
        AllHandlers,
        /**
         * Message should be delivered to all handlers. Most recent stateful message is queued and also delivered to each new handler.
         */
        Stateful
    }

    public abstract Delivery getDelivery();

    def services = new DefaultServiceRegistry()

    def setup() {
        services.add(listenerManager)
    }

    def "automatically creates and registers stateful listener when first event is broadcast"() {
        def created = Mock(Runnable)
        def listener = Mock(TestListener)

        when:
        services.addProvider(new ServiceRegistrationProvider() {

#include <vector>

#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project

namespace mlir {
namespace TFL {

// Check if the given op has stateful operands and return their stateful
// operand indices.
bool IsStatefulOp(Operation* op, std::vector<int>* stateful_operand_indices);

}  // namespace TFL
}  // namespace mlir

 */
public interface ExternalComponentGraphResolveState extends ComponentGraphResolveState {

    /**
     * @deprecated Try to avoid using this. This method exposes legacy stateful metadata. Usages should be
     * replaced by using the stateful types like {@link ComponentGraphResolveState} and
     * {@link org.gradle.internal.component.model.ComponentArtifactResolveState}.
     */
    @Deprecated

      tf_executor.yield
    }
    tf_executor.fetch
  }
  func.return
}

// -----

// Check that we report an unexpected dependency path between a stateless and a
// stateful op.
func.func @source_stateless_target_stateful() -> () {
  tf_executor.graph {
    // expected-warning@+1 {{unexpected control dependency path: path 0, node 0 (source)}}
    %island1 = tf_executor.island {