%push = "tf.StackPushV2"(%stack, %elem) {swap_memory = false} : (tensor<!tf_type.resource>, tensor<2xi32>) -> tensor<2xi32>
  "tf.StackCloseV2"(%stack) : (tensor<!tf_type.resource>) -> ()
  // CHECK-NEXT: return %[[PUSH_VAL]] : tensor<2xi32>
  func.return %push : tensor<2xi32>
}

// -----

// Tests while loop.

// CHECK-LABEL: func @main

	CALL	AX

	MOVL	0x08(SP), BP
	MOVL	0x0C(SP), BX
	MOVL	0x10(SP), AX
	MOVL	0x14(SP), CX
	MOVL	0x18(SP), DX
	RET

TEXT _rt0_386_windows_lib_go(SB),NOSPLIT,$0
	PUSHL	$0
	PUSHL	$0
	JMP	runtime·rt0_go(SB)

TEXT _main(SB),NOSPLIT,$0
	// Remove the return address from the stack.
	// rt0_go doesn't expect it to be there.
	ADDL	$4, SP

    func::FuncOp root, SymbolTable &symtab,
    const std::function<bool(SymbolUserOpInterface)> &predicate,
    llvm::SmallVector<SymbolUserOpInterface> &ops) {
  std::stack<func::FuncOp> worklist;
  worklist.push(root);
  while (!worklist.empty()) {
    func::FuncOp u = worklist.top();
    worklist.pop();
    auto result = u.walk([&](SymbolUserOpInterface op) {
      if (llvm::isa<T, Types...>(op) && (!predicate || predicate(op))) {

					pushes[proxy.ID()]++
					pushesMu.Unlock()
				case <-stopCh:
					return
				}
			}
		}()
	}
	go doSendPushes(stopCh, semaphore, queue)

	for push := 0; push < 100; push++ {
		for _, proxy := range proxies {
			queue.Enqueue(proxy, &model.PushRequest{Push: &model.PushContext{}})
		}
		time.Sleep(time.Millisecond * 10)
	}
	for queue.Pending() > 0 {
		time.Sleep(time.Millisecond)
	}
	pushesMu.Lock()

func findWaypointResources(node *model.Proxy, push *model.PushContext) ([]model.WorkloadInfo, *waypointServices) {
	key := model.WaypointKeyForProxy(node)
	workloads := push.WorkloadsForWaypoint(key)
	serviceInfos := push.ServicesForWaypoint(key)

	waypointServices := &waypointServices{}
	for _, s := range serviceInfos {
		hostName := host.Name(s.Service.Hostname)
		svc, ok := push.ServiceIndex.HostnameAndNamespace[hostName][s.Namespace]

    def "assemble with local cache (build comparison)"() {
        def noPushInitScript = temporaryFolder.file("no-push.gradle")
        noPushInitScript << """
            settingsEvaluated { settings ->
                settings.buildCache {
                    local {
                        push = false
                    }
                }
            }
        """.stripIndent()

        given:

		AddFunc: func(pod *corev1.Pod) {
			q.Push(func() error {
				return handlers.added(pod)
			})
		},
		UpdateFunc: func(old, cur *corev1.Pod) {
			q.Push(func() error {
				if old.GetResourceVersion() != cur.GetResourceVersion() {
					return handlers.updated(cur)
				}
				return nil
			})
		},
		DeleteFunc: func(pod *corev1.Pod) {
			q.Push(func() error {
				return handlers.deleted(pod)
			})
		},

// needsPush checks whether the passed in config has same spec and hence push needs
// to be triggered. This is to avoid unnecessary pushes only when labels have changed
// for example.
func needsPush(prev config.Config, curr config.Config) bool {
	if prev.GroupVersionKind != curr.GroupVersionKind {
		// This should never happen.
		return true
	}
	// If the config is not Istio, let us just push.
	if !strings.HasSuffix(prev.GroupVersionKind.Group, "istio.io") {

                @TaskAction void doSomething() {
                    outputFile.text = inputFile.text + cacheOrigin.text
                }
            }
        """.stripIndent()
    }

    def 'push to local'() {
        pushToLocal()

        when:
        withBuildCache().run cacheableTask

        then:
        executedAndNotSkipped(cacheableTask)

type queueTask struct {
	task        Task
	enqueueTime time.Time
	startTime   time.Time
}

// Instance of work tickets processed using a rate-limiting loop
type baseInstance interface {
	// Push a task.
	Push(task Task)
	// Run the loop until a signal on the channel
	Run(<-chan struct{})
	// Closed returns a chan that will be signaled when the Instance has stopped processing tasks.
	Closed() <-chan struct{}
}