}

// Follows the structure of Live-variable analysis. It is a form of
// CFG (Control Flow Graph) analysis, often used in compilers.
//
// A variable is live if it holds a value that may be used in the future.
// It is live-in at node n if it is live on any of the node's in-edges.
// It is live-out at node n if it is live on any of the node's out-edges.
// def[n] refers to values that are defined at node n.

     */
    interface CrossBuildSession extends Global {}

    /**
     * These services are reused across build invocations in a session.
     *
     * A build session can be long-lived in a continuous build (where these services would be reused) or short-lived in a
     * regular, single build.
     *

  if (!has_resources) return success();

  // We initially assign the argument for a resource as the live value for the
  // resource. We then walk through the operations in the function in their
  // lexical order, to update the live value for the resource when we see a
  // store to the resource and replace reads of the resource with uses of its
  // live value.
  for (Operation& op : llvm::make_early_inc_range(block)) {

}

// reset fills state with the live variables from live.
func (state *stateAtPC) reset(live abt.T) {
	slots, registers := state.slots, state.registers
	for i := range slots {
		slots[i] = VarLoc{}
	}
	for i := range registers {
		registers[i] = registers[i][:0]
	}
	for it := live.Iterator(); !it.Done(); {
		k, d := it.Next()
		live := d.(*liveSlot)
		slots[k] = live.VarLoc
		if live.VarLoc.Registers == 0 {

[[find_all_daemons]]
== Find Daemons

If you have installed the Java Development Kit (JDK), you can view live daemons with the `jps` command.

----
$ jps
----
----
33920 Jps
27171 GradleDaemon
22792
----

Live Daemons appear under the name `GradleDaemon`.
Because this command uses the JDK, you can view Daemons running any version of Gradle.

[[enable_deamon]]

    )
}

dependencies {
    api(projects.serviceProvider)
    api(project(":core-api"))
    api(project(":core"))
    api(project(":ide")) {
        because("To pick up various builders (which should live somewhere else)")
        api(project(":tooling-api"))
    }

    implementation(projects.baseServices)
    implementation(project(":file-collections"))
    implementation(project(":language-native"))

	// mark all live revisions
	live := map[string]bool{}
	if current != nil {
		live[current.Name] = true
	}
	if update != nil {
		live[update.Name] = true
	}
	for i := range pods {
		live[getPodRevision(pods[i])] = true
	}
	// collect live revisions and historic revisions
	for i := range revisions {
		if !live[revisions[i].Name] {

    integTestDistributionRuntimeOnly(project(":distributions-basics"))  {
        because("Requires ':toolingApiBuilders': Event handlers are in the wrong place, and should live in this project")
    }

                fieldPath: spec.serviceAccountName
          - name: KUBECONFIG
            value: /var/run/secrets/remote/config
          # If you explicitly told us where ztunnel lives, use that.
          # Otherwise, assume it lives in our namespace
          # Also, check for an explicit ENV override (legacy approach) and prefer that
          # if present

	// Look for a Pod using pvc in the Informer's cache. If one is found the
	// correct decision to keep pvc is taken without doing an expensive live
	// list.
	logger := klog.FromContext(ctx)
	if inUse, err := c.askInformer(logger, pvc); err != nil {
		// No need to return because a live list will follow.
		logger.Error(err, "")
	} else if inUse {
		return true, nil
	}