code: func ResourceLimitsPriorityMap(pod *v1.Pod, meta interface{}, nodeInfo *schedulernodeinfo.NodeInfo) (schedulerapi.HostPriority, error) {
  	node := nodeInfo.Node()
  	if node == nil {
  		return schedulerapi.HostPriority{}, fmt.Errorf("node not found")
  	}
  
  	allocatableResources := nodeInfo.AllocatableResource()
  
  	// compute pod limits
  	podLimits := getResourceLimits(pod)
  
  	cpuScore := computeScore(podLimits.MilliCPU, allocatableResources.MilliCPU)
  	memScore := computeScore(podLimits.Memory, allocatableResources.Memory)
  
  	score := int(0)
  	if cpuScore == 1 || memScore == 1 {
  		score = 1
  	}
  
  	if klog.V(10) {
  		// We explicitly don't do klog.V(10).Infof() to avoid computing all the parameters if this is
  		// not logged. There is visible performance gain from it.
  		klog.Infof(
  			"%v -> %v: Resource Limits Priority, allocatable %d millicores %d memory bytes, pod limits %d millicores %d memory bytes, score %d",
  			pod.Name, node.Name,
  			allocatableResources.MilliCPU, allocatableResources.Memory,
  			podLimits.MilliCPU, podLimits.Memory,
  			score,
  		)
  	}
  
  	return schedulerapi.HostPriority{
  		Host:  node.Name,
  		Score: score,
  	}, nil
  }
docs: // ResourceLimitsPriorityMap is a priority function that increases score of input node by 1 if the node satisfies
  // input pod's resource limits. In detail, this priority function works as follows: If a node does not publish its
  // allocatable resources (cpu and memory both), the node score is not affected. If a pod does not specify
  // its cpu and memory limits both, the node score is not affected. If one or both of cpu and memory limits
  // of the pod are satisfied, the node is assigned a score of 1.
  // Rationale of choosing the lowest score of 1 is that this is mainly selected to break ties between nodes that have
  // same scores assigned by one of least and most requested priority functions.