// cpu and memory.
	useRequested bool
	scorer       func(requested, allocable []int64) int64
	resources    []config.ResourceSpec
}

// score will use `scorer` function to calculate the score.
func (r *resourceAllocationScorer) score(
	ctx context.Context,
	pod *v1.Pod,
	nodeInfo *framework.NodeInfo,
	podRequests []int64) (int64, *framework.Status) {
	logger := klog.FromContext(ctx)
	node := nodeInfo.Node()

func NewScope(parent *Scope, pos, end syntax.Pos, comment string) *Scope {
	s := &Scope{parent, nil, 0, nil, pos, end, comment, false}
	// don't add children to Universe scope!
	if parent != nil && parent != Universe {
		parent.children = append(parent.children, s)
		s.number = len(parent.children)
	}
	return s
}

// Parent returns the scope's containing (parent) scope.
func (s *Scope) Parent() *Scope { return s.parent }

// and looked up by name. The zero value for Scope is a ready-to-use
// empty scope.
type Scope struct {
	parent   *Scope
	children []*Scope
	number   int               // parent.children[number-1] is this scope; 0 if there is no parent
	elems    map[string]Object // lazily allocated
	pos, end token.Pos         // scope extent; may be invalid
	comment  string            // for debugging only

			s.nameToEmit = name
		}

		scopes[name] = s
	}

	s.labels = make(map[string]any)

	return s
}

// FindScope returns a previously registered scope, or nil if the named scope wasn't previously registered
func FindScope(scope string) *Scope {
	lock.RLock()
	defer lock.RUnlock()

	s := scopes[scope]
	return s
}

// Scopes returns a snapshot of the currently defined set of scopes

org.gradle.internal.service.scopes.CoreServices
org.gradle.caching.internal.BuildCacheServices
org.gradle.internal.service.scopes.ExecutionServices

}

// NewScope creates a new scope nested in the outer scope.
func NewScope(outer *Scope) *Scope {
	const n = 4 // initial scope capacity
	return &Scope{outer, make(map[string]*Object, n)}
}

// Lookup returns the object with the given name if it is
// found in scope s, otherwise it returns nil. Outer scopes
// are ignored.
func (s *Scope) Lookup(name string) *Object {
	return s.Objects[name]
}

  // scopes, or scopes derived from an existing scope object.

  /// Return a new scope.
  /// This creates a new graph and all operations constructed in this graph
  /// should use the returned object as the "root" scope.
  static Scope NewRootScope();

  /// Return a new scope. Ops created with this scope will have

  ./testdata/scopes.go
22:	func test() {
23:		x := id(0)
24:		y := id(0)
25:		fmt.Println(x)
26:		for i := x; i < 3; i++ {
27:			x := i * i
28:			y += id(x) //gdb-dbg=(x,y)//gdb-opt=(x,y)
26:		for i := x; i < 3; i++ {
27:			x := i * i
28:			y += id(x) //gdb-dbg=(x,y)//gdb-opt=(x,y)
26:		for i := x; i < 3; i++ {
27:			x := i * i
28:			y += id(x) //gdb-dbg=(x,y)//gdb-opt=(x,y)
26:		for i := x; i < 3; i++ {
31:		fmt.Println(x, y)

  src/cmd/compile/internal/ssa/testdata/scopes.go
22:	func test() {
23:		x := id(0)
24:		y := id(0)
25:		fmt.Println(x)
0:
27:			x := i * i
28:			y += id(x) //gdb-dbg=(x,y)//gdb-opt=(x,y)
x = 0
y = 0
26:		for i := x; i < 3; i++ {
27:			x := i * i
28:			y += id(x) //gdb-dbg=(x,y)//gdb-opt=(x,y)
x = 1
y = 0
26:		for i := x; i < 3; i++ {
27:			x := i * i
28:			y += id(x) //gdb-dbg=(x,y)//gdb-opt=(x,y)
x = 4
y = 1

package serviceentry

import (
	"k8s.io/apimachinery/pkg/types"

	"istio.io/istio/pilot/pkg/model"
	"istio.io/istio/pkg/util/sets"
)

type hostPort struct {
	host instancesKey
	port int
}

// stores all the service instances from SE, WLE and pods
type serviceInstancesStore struct {
	ip2instance map[string][]*model.ServiceInstance
	// service instances by hostname -> config