// RUN: tf-opt %s -tfl-pin-ops-with-side-effects | FileCheck %s

func.func @id(%arg0: tensor<1xf32>)->tensor<1xf32> {
  func.return %arg0 : tensor<1xf32>
}

func.func @noop()->() {
  func.return
}

// CHECK-LABEL: @tf_if_gets_control_node
func.func @tf_if_gets_control_node(%arg0: tensor<1xi1>)->() {

  llvm::SmallDenseSet<Value, 8> processed_values;
  for (const auto& effect : effects) {
    Value value = effect.getValue();
    found_any_effect = true;

    // We only collect value-based side effects here for which we can use
    // resource alias analysis. Other side effects are treated as op-based
    // side effects.
    if (!ShouldUseResourceAliasAnalysis(effect)) continue;

void MarkResourceAsReadAndWrite(
    Value value,
    SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>&
        effects) {
  if (value.getType().cast<TensorType>().getElementType().isa<ResourceType>()) {
    effects.emplace_back(MemoryEffects::Read::get(), value,
                         ResourceEffects::Variable::get());
    effects.emplace_back(MemoryEffects::Write::get(), value,
                         ResourceEffects::Variable::get());

        }
        source.addPendingCollection(provider5)

        then:
        0 * _ // no side effects until elements are realized

        when:
        source.removePending(provider2)
        source.removePendingCollection(provider4)

        then:
        0 * _ // can remove pending without running side effects

        when:
        source.realizePending()

        then:
        0 * sideEffect1.execute("v1")

		fmt.Printf("index after range with side-effect = %d want %d\n", i, want)
		os.Exit(1)
	}

	i = n + 1
	// i is shadowed here, so its value should be unchanged.
	for i := range s {
		s[i] = 0
	}
	if want := n + 1; i != want {
		fmt.Printf("index after range without side-effect = %d want %d\n", i, want)
		os.Exit(1)
	}

	// Index variable whose evaluation has side-effects
	var x int
	f := func() int {
		x++

        provider.calculateExecutionTimeValue()

        then:
        0 * _ // no side effects when calculating wrapped values

        when:
        counter.set(23)
        def unpackedValue = provider.get()

        then:
        unpackedValue == 46
        // Side effect of the provider returned by transform is executed first.
        // See FlatMapProvider for details

  }

  return nullptr;
}

// Returns true if the op can have side effects.
bool TensorFlowDialect::CanHaveSideEffects(Operation *op) {
  // If the op has no memory side effects, it has no side effects
  if (isMemoryEffectFree(op)) return false;

  // If the op is marked stateless using the `is_stateless` attribute, then
  // it has no side effects.
  if (auto is_stateless = op->getAttrOfType<BoolAttr>("is_stateless"))

  return tensor_type &&
         mlir::isa<mlir::TF::ResourceType>(tensor_type.getElementType());
}

// The default criterion for operations being considered as causing or being
// dependent on side effects. Reflects the current runtime logic; see below.
bool OpHasSideEffects(Operation *op) {
  // Note that TFL::IfOp are only ever instantiated in flatbuffer_export; until

### Important notices

Decreasing resource requirements for cluster addons may cause system instability. The effects may include (but are not limited to):
  - Horizontal Pod Autoscaler not working
  - `kubectl top` not working (starting with Kubernetes 1.10)

package main

import "os"

// Too small to trigger deadcode (currently)
var small = map[string]int{"foo": 1}

// Has side effects, which prevent deadcode
var effect = map[string]int{"foo": os.Getpid()}

// Large and side-effect free
var large = map[string]int{
	"11": 1, "12": 2, "13": 3, "14": 4, "15": 5, "16": 6, "17": 7, "18": 8, "19": 9, "110": 10,
	"21": 1, "22": 2, "23": 3, "24": 4, "25": 5, "26": 6, "27": 7, "28": 8, "29": 9, "210": 10,