2020-06-29T23:37:27.672377Z	info	sds	resource:default pushed key/cert pair to proxy
2020-06-29T23:37:29.663179Z	info	sds	resource:ROOTCA new connection
2020-06-29T23:37:29.663470Z	info	sds	Skipping waiting for ingress gateway secret
2020-06-29T23:37:29.663545Z	info	cache	Loaded root cert from certificate ROOTCA
2020-06-29T23:37:29.663899Z	info	sds	resource:ROOTCA pushed root cert to proxy
2020-06-29T23:37:30.890178Z	info	Envoy proxy is ready

          num_elements *= tensor.getDimSize(i);
        }
      }
      return num_elements;
    };

    // If the op is the pass-through op with (3x) smaller output, the dequantize
    // op can be pushed down to the single result of this op.
    if (!llvm::dyn_cast<mlir::SameScalesOpInterface>(passthrough_op) ||
        passthrough_op->getNumResults() != 1) {
      return failure();
    }

	c.set_pc(uint64(abi.FuncPCABIInternal(sigpanic)))
}

func (c *sigctxt) pushCall(targetPC, resumePC uintptr) {
	// Push the LR to stack, as we'll clobber it in order to
	// push the call. The function being pushed is responsible
	// for restoring the LR and setting the SP back.
	// This extra space is known to gentraceback.
	sp := c.sp() - sys.MinFrameSize
	c.set_sp(sp)
	*(*uint64)(unsafe.Pointer(uintptr(sp))) = c.link()

// the processing go routine should stop.
func (q *queueImpl) get() (task *queueTask, shutdown bool) {
	q.cond.L.Lock()
	defer q.cond.L.Unlock()
	// wait for closing to be set, or a task to be pushed
	for !q.closing && len(q.tasks) == 0 {
		q.cond.Wait()
	}

	if q.closing && len(q.tasks) == 0 {
		// We must be shutting down.
		return nil, true
	}
	task = q.tasks[0]

	c.set_pc(uint64(abi.FuncPCABIInternal(sigpanic)))
}

func (c *sigctxt) pushCall(targetPC, resumePC uintptr) {
	// Push the LR to stack, as we'll clobber it in order to
	// push the call. The function being pushed is responsible
	// for restoring the LR and setting the SP back.
	// This extra space is known to gentraceback.
	sp := c.sp() - 16 // SP needs 16-byte alignment
	c.set_sp(sp)
	*(*uint64)(unsafe.Pointer(uintptr(sp))) = c.lr()

	c.set_pc(uint64(abi.FuncPCABIInternal(sigpanic)))
}

func (c *sigctxt) pushCall(targetPC, resumePC uintptr) {
	// Push the LR to stack, as we'll clobber it in order to
	// push the call. The function being pushed is responsible
	// for restoring the LR and setting the SP back.
	// This extra slot is known to gentraceback.
	sp := c.sp() - 8
	c.set_sp(sp)
	*(*uint64)(unsafe.Pointer(uintptr(sp))) = c.link()

// from API Server containing information that requires updating service rules. It
// indicates that the proxier for the given IP family has received changes but has not
// yet pushed them to its backend. If the proxier does not call Updated within the
// healthTimeout time then it will be considered unhealthy.
func (hs *ProxierHealthServer) QueuedUpdate(ipFamily v1.IPFamily) {
	hs.lock.Lock()

determine which *types* may be impacted. For example, we know a `WasmPlugin` does not impact the `Cluster` type, so we can skip generating `Cluster` in this case. Warning: Envoy currently has a bug that *requires* `Endpoints` to be pushed any time the corresponding `Cluster` is pushed, so this optimization is intentionally turned off in this specific case.

Finally, we determine which subset of the type we need to generate. XDS has two modes - "State of the World (SotW)" and "Delta". In SotW, we...

                this.requestedJvmCriteria = new DaemonJvmCriteria(javaVersion, DefaultJvmVendorSpec.any(), JvmImplementation.VENDOR_SPECIFIC);
            } catch (Exception e) {
                // TODO: This should be pushed somewhere else so we consistently report this message in the right context.

        !localCache.hasCacheEntry(cacheKey)
        localCache.listCacheTempFiles().empty
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)
    def "archive is not pushed to remote when packing fails"() {
        executer.withStacktraceEnabled()

        when:
        file("input.txt") << "data"
        settingsFile << remoteCache.remoteCacheConfiguration()