type PriorityQueue struct {
        stop  chan struct{}
        clock util.Clock
        // pod initial backoff duration.
        podInitialBackoffDuration time.Duration
        // pod maximum backoff duration.
        podMaxBackoffDuration time.Duration

        lock sync.RWMutex

        cond sync.Cond

        // activeQ is heap structure that scheduler actively looks at to find pods to
        // schedule. Head of heap is the highest priority pod.
        activeQ *heap.Heap   存放待调度的Pod，每次调度从中pop一个pod出来

        // podBackoffQ is a heap ordered by backoff expiry. Pods which have completed backoff
        // are popped from this heap before the scheduler looks at activeQ
        podBackoffQ *heap.Heap  存放backoff状态的pod

        // unschedulableQ holds pods that have been tried and determined unschedulable.
        unschedulableQ *UnschedulablePodsMap  存放Unschedulable状态的**pod

        // nominatedPods is a structures that stores pods which are nominated to run
        // on nodes.
        nominatedPods *nominatedPodMap

        // schedulingCycle represents sequence number of scheduling cycle and is incremented
        // when a pod is popped.
        schedulingCycle int64   递增的序列，类似ETCD的Index，每次pop pod时增加

        // moveRequestCycle caches the sequence number of scheduling cycle when we
        // received a move request. Unscheduable pods in and before this scheduling
        // cycle will be put back to activeQueue if we were trying to schedule them
        // when we received move request.
        moveRequestCycle int64  记录上一次移动unschedulableQ的pod到podBackoffQ的序列

        // closed indicates that the queue is closed.
        // It is mainly used to let Pop() exit its control loop while waiting for an item.
        closed bool
}

// Heap is a producer/consumer queue that implements a heap data structure.
// It can be used to implement priority queues and similar data structures.
type Heap struct {
        // data stores objects and has a queue that keeps their ordering according
        // to the heap invariant.
        data *data

        // metricRecorder updates the counter when elements of a heap get added or
        // removed, and it does nothing if it's nil
        metricRecorder metrics.MetricRecorder
}

type data struct {
        // items is a map from key of the objects to the objects and their index.
        // We depend on the property that items in the map are in the queue and vice versa.
        items map[string]*heapItem

        // queue implements a heap data structure and keeps the order of elements
        // according to the heap invariant. The queue keeps the keys of objects stored
        // in "items".
        queue []string

        // keyFunc is used to make the key used for queued item insertion and retrieval, and
        // should be deterministic.
        keyFunc KeyFunc

        // lessFunc is used to compare two objects in the heap.
        lessFunc lessFunc
}

// Profiles are required to have equivalent queue sort plugins.
lessFn := profiles[c.profiles[0].SchedulerName].QueueSortFunc()
podQueue := internalqueue.NewSchedulingQueue(
	lessFn,
	internalqueue.WithPodInitialBackoffDuration(time.Duration(c.podInitialBackoffSeconds)*time.Second),
	internalqueue.WithPodMaxBackoffDuration(time.Duration(c.podMaxBackoffSeconds)*time.Second),
	internalqueue.WithPodNominator(nominator),
)

// QueueSortFunc returns the function to sort pods in scheduling queue
func (f *frameworkImpl) QueueSortFunc() framework.LessFunc {
	if f == nil {
		// If frameworkImpl is nil, simply keep their order unchanged.
		// NOTE: this is primarily for tests.
		return func(_, _ *framework.QueuedPodInfo) bool { return false }
	}

	if len(f.queueSortPlugins) == 0 {
		panic("No QueueSort plugin is registered in the frameworkImpl.")
	}

	// Only one QueueSort plugin can be enabled.
	return f.queueSortPlugins[0].Less
}

// Less is the function used by the activeQ heap algorithm to sort pods.
// It sorts pods based on their priority. When priorities are equal, it uses
// PodQueueInfo.timestamp.
func (pl *PrioritySort) Less(pInfo1, pInfo2 *framework.QueuedPodInfo) bool {
	p1 := corev1helpers.PodPriority(pInfo1.Pod)
	p2 := corev1helpers.PodPriority(pInfo2.Pod)
	return (p1 > p2) || (p1 == p2 && pInfo1.Timestamp.Before(pInfo2.Timestamp))
}

func (p *PriorityQueue) podsCompareBackoffCompleted(podInfo1, podInfo2 interface{}) bool {
	pInfo1 := podInfo1.(*framework.QueuedPodInfo)
	pInfo2 := podInfo2.(*framework.QueuedPodInfo)
	bo1 := p.getBackoffTime(pInfo1)
	bo2 := p.getBackoffTime(pInfo2)
	return bo1.Before(bo2)
}

type UnschedulablePodsMap struct {
	// podInfoMap is a map key by a pod's full-name and the value is a pointer to the QueuedPodInfo.
	podInfoMap map[string]*framework.QueuedPodInfo
	keyFunc    func(*v1.Pod) string
	// metricRecorder updates the counter when elements of an unschedulablePodsMap
	// get added or removed, and it does nothing if it's nil
	metricRecorder metrics.MetricRecorder
}