if n.Comm != nil {
			Walk(v, n.Comm)
		}
		walkList(v, n.Body)

	case *SelectStmt:
		Walk(v, n.Body)

	case *ForStmt:
		if n.Init != nil {
			Walk(v, n.Init)
		}
		if n.Cond != nil {
			Walk(v, n.Cond)
		}
		if n.Post != nil {
			Walk(v, n.Post)
		}
		Walk(v, n.Body)

	case *RangeStmt:
		if n.Key != nil {
			Walk(v, n.Key)
		}
		if n.Value != nil {
			Walk(v, n.Value)

		if err != nil {
			lastError = err
			klog.V(2).Infof("could not get Job %q in the namespace %q, retrying: %v", jobName, ns, err)
			return false, nil
		}
		for _, cond := range job.Status.Conditions {
			if cond.Type == batchv1.JobComplete {
				return true, nil
			}
		}
		lastError = errors.Errorf("no condition of type %v", batchv1.JobComplete)

			cc := s.(*ast.CommClause)
			if !check.isTerminatingList(cc.Body, "") || hasBreakList(cc.Body, label, true) {
				return false
			}

		}
		return true

	case *ast.ForStmt:
		if s.Cond == nil && !hasBreak(s.Body, label, true) {
			return true
		}
	}

	return false
}

func (check *Checker) isTerminatingList(list []ast.Stmt, label string) bool {

	f       func(T) // function to run for each item
	running int     // total number of runners

	mu      sync.Mutex
	added   map[T]bool // items added to set
	todo    []T        // items yet to be run
	wait    sync.Cond  // wait when todo is empty
	waiting int        // number of runners waiting for todo
}

func (w *Work[T]) init() {
	if w.added == nil {
		w.added = make(map[T]bool)
	}
}

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(QuantizeVariablesPass)
  explicit QuantizeVariablesPass() = default;

  void runOnOperation() override;

 private:
  // Outlines the regions of the WhileOp's cond and body and insert function
  // calls instead.
  void QuantizeVariable(OpBuilder &builder,
                        const std::vector<VarHandleOp> &var_handle_op);
};

void QuantizeVariablesPass::QuantizeVariable(

Do mesmo modo, você pode definir a lógica (código) que será executada quando a aplicação estiver sendo **encerrada**. Nesse caso, este código será executado **uma vez**, **depois** de ter possivelmente tratado **várias requisições**.

    // CHECK-NEXT: tfrt.merge.chains
    // CHECK-NEXT: tfrt.return
    %0 = "tf.Const"() {device = "/device:CPU:0", value = dense<0> : tensor<i32>} : () -> tensor<i32>
    %1 = "tf.While"(%0) { cond = @while_cond_lt9, body = @while_body_add2, is_stateless = false, parallel_iterations = 1} : (tensor<i32>) -> (tensor<i32>)
    func.return %1 : tensor<i32>
  }
  // CHECK: func @"[[while_func_prefix]]/tfrt_body_1"

  %2 = mhlo.constant dense<20> : tensor<i32>
  // CHECK-NEXT: mhlo.while
  %3, %4, %5 = mhlo.while(%iterArg = %1, %iterArg_0 = %0, %iterArg_1 = %1) : tensor<i32>, tensor<i32>, tensor<i32>
   cond {
    %17 = mhlo.compare  LT, %iterArg_1, %2 : (tensor<i32>, tensor<i32>) -> tensor<i1>
    mhlo.return %17 : tensor<i1>
  } do {
    mhlo.return %0, %0, %0 : tensor<i32>, tensor<i32>, tensor<i32>
  }
  return
}

String id=4
	data="GC (idle)"
String id=5
	data="unspecified"
String id=6
	data="forever"
String id=7
	data="network"
String id=8
	data="select"
String id=9
	data="sync.(*Cond).Wait"
String id=10
	data="sync"
String id=11
	data="chan send"
String id=12
	data="chan receive"
String id=13
	data="GC mark assist wait for work"
String id=14
	data="GC background sweeper wait"