// Before accessing the cacher's cache, wait for the ready to be ok.
	// This is necessary to prevent users from accessing structures that are
	// uninitialized or are being repopulated right now.
	// ready needs to be set to false when the cacher is paused or stopped.
	// ready needs to be set to true when the cacher is ready to use after
	// initialization.
	ready *ready

	// Underlying storage.Interface.

    if (info.is_read) {
      Operation* read = builder.create<TF::ReadVariableOp>(
          op_->getLoc(), info.data_type, resource);
      read->setAttrs(info.read_attrs ? info.read_attrs : empty_attrs);
      read->removeAttr(kDeviceAttr);
      info.hoisted_read = read->getResult(0);
    }
  }
}

// Replaces all resource reads with the hoisted read.

		},
		{
			desc: "new, ready: soft requirement warning",
			node: withCapacity.DeepCopy(),
			cmStatus: cm.Status{
				SoftRequirements: fmt.Errorf("foo"),
			},
			expectConditions: []v1.NodeCondition{*makeReadyCondition(true, "kubelet is posting ready status. WARNING: foo", now, now)},
		},
		{
			desc:             "new, not ready: storage errors",
			node:             withCapacity.DeepCopy(),

			c := make(chan int)
			var ready, done sync.WaitGroup
			defer func() {
				close(c)
				done.Wait()
			}()

			for i := 0; i < n; i++ {
				ready.Add(1)
				done.Add(1)
				go func() {
					ready.Done()
					<-c
					done.Done()
				}()
			}
			// Let goroutines block on channel
			ready.Wait()
			for i := 0; i < 5; i++ {
				runtime.Gosched()

			}
			return r.Sym
		}
	}
	base.Fatalf("fixedSym data not known for %s:%d", sym, off)
	return nil
}

// read8 reads one byte from the read-only global sym at offset off.
func read8(sym interface{}, off int64) uint8 {
	lsym := sym.(*obj.LSym)
	if off >= int64(len(lsym.P)) || off < 0 {
		// Invalid index into the global sym.

		// an unscheduled, pending pod
		// a scheduled, pending pod
		// a scheduled, running, not-ready pod
		// a scheduled, running, ready pod on same node as a related pod
		// a scheduled, running, ready pod not on node with related pods
		// Note that a pending pod cannot be ready
		{
			name:                 "len(pods) = 0 (i.e., diff = 0 too)",
			pods:                 []*v1.Pod{},

        startupProbe:
          httpGet:
            path: /healthz/ready
            port: 15021
          initialDelaySeconds: 0
          periodSeconds: 1
          timeoutSeconds: 3
          failureThreshold: {{ .Values.global.proxy.startupProbe.failureThreshold }}
      {{ end }}
        readinessProbe:
          httpGet:
            path: /healthz/ready
            port: 15021

        startupProbe:
          httpGet:
            path: /healthz/ready
            port: 15021
          initialDelaySeconds: 0
          periodSeconds: 1
          timeoutSeconds: 3
          failureThreshold: {{ .Values.global.proxy.startupProbe.failureThreshold }}
      {{ end }}
        readinessProbe:
          httpGet:
            path: /healthz/ready
            port: 15021

        startupProbe:
          httpGet:
            path: /healthz/ready
            port: 15021
          initialDelaySeconds: 0
          periodSeconds: 1
          timeoutSeconds: 3
          failureThreshold: {{ .Values.global.proxy.startupProbe.failureThreshold }}
      {{ end }}
        readinessProbe:
          httpGet:
            path: /healthz/ready
            port: 15021

		// are waiting for all pointers into them to go away. Sweeping handles
		// identifying when this is true, and moves the span to the ready list.
		quarantineList mSpanList

		// readyList is a list of empty user arena spans that are ready for reuse.
		readyList mSpanList
	}

	unused *specialfinalizer // never set, just here to force the specialfinalizer type into DWARF
}

var mheap_ mheap