github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-30 06:54:01 +00:00
Code Issues Projects Releases Wiki Activity

Simplify schedulers.

Browse Source
This commit is contained in:
Brendan Burns 2014-09-25 11:36:22 -07:00
parent da92a016f5
commit 44703efe2e
7 changed files with 18 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
pkg/scheduler/generic_scheduler.go
View File

@ -100,6 +100,23 @@ func getMinHosts(list HostPriorityList) []string {
return result
}
func evenPriority(pod api.Pod, podLister PodLister, minionLister MinionLister) (HostPriorityList, error) {
nodes, err := minionLister.List()
result := []HostPriority{}
if err != nil {
fmt.Errorf("failed to list nodes: %v", err)
return []HostPriority{}, err
}
for _, minion := range nodes {
result = append(result, HostPriority{
host: minion,
score: 1,
})
}
return result, nil
}
func NewGenericScheduler(predicates []FitPredicate, prioritizer PriorityFunction, pods PodLister, random *rand.Rand) Scheduler {
return &genericScheduler{
predicates: predicates,

17
pkg/scheduler/generic_scheduler_test.go
View File

@ -29,23 +29,6 @@ func matchesPredicate(pod api.Pod, existingPods []api.Pod, node string) (bool, e
return pod.ID == node, nil
}
func evenPriority(pod api.Pod, podLister PodLister, minionLister MinionLister) (HostPriorityList, error) {
nodes, err := minionLister.List()
result := []HostPriority{}
if err != nil {
fmt.Errorf("failed to list nodes: %v", err)
return []HostPriority{}, err
}
for _, minion := range nodes {
result = append(result, HostPriority{
host: minion,
score: 1,
})
}
return result, nil
}
func numericPriority(pod api.Pod, podLister PodLister, minionLister MinionLister) (HostPriorityList, error) {
nodes, err := minionLister.List()
result := []HostPriority{}

48
pkg/scheduler/random.go
View File

@ -1,48 +0,0 @@
/*
Copyright 2014 Google Inc. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package scheduler
import (
"math/rand"
"sync"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
)
// RandomScheduler chooses machines uniformly at random.
type RandomScheduler struct {
random *rand.Rand
randomLock sync.Mutex
}
func NewRandomScheduler(random *rand.Rand) Scheduler {
return &RandomScheduler{
random: random,
}
}
// Schedule schedules a given pod to a random machine.
func (s *RandomScheduler) Schedule(pod api.Pod, minionLister MinionLister) (string, error) {
machines, err := minionLister.List()
if err != nil {
return "", err
}
s.randomLock.Lock()
defer s.randomLock.Unlock()
return machines[s.random.Int()%len(machines)], nil
}

34
pkg/scheduler/random_test.go
View File

@ -1,34 +0,0 @@
/*
Copyright 2014 Google Inc. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package scheduler
import (
"math/rand"
"testing"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
)
func TestRandomScheduler(t *testing.T) {
random := rand.New(rand.NewSource(0))
st := schedulerTester{
t: t,
scheduler: NewRandomScheduler(random),
minionLister: FakeMinionLister{"m1", "m2", "m3", "m4"},
}
st.expectSuccess(api.Pod{})
}

51
pkg/scheduler/randomfit.go
View File

@ -17,22 +17,12 @@ limitations under the License.
package scheduler
import (
"fmt"
"math/rand"
"sync"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
)
// RandomFitScheduler is a Scheduler which schedules a Pod on a random machine which matches its requirement.
type RandomFitScheduler struct {
podLister PodLister
predicates []FitPredicate
random *rand.Rand
randomLock sync.Mutex
}
// NewRandomFitScheduler creates a random fit scheduler with the default set of fit predicates
func NewRandomFitScheduler(podLister PodLister, random *rand.Rand) Scheduler {
return NewRandomFitSchedulerWithPredicates(podLister, random, []FitPredicate{podFitsPorts})
@ -41,11 +31,7 @@ func NewRandomFitScheduler(podLister PodLister, random *rand.Rand) Scheduler {
// NewRandomFitScheduler creates a random fit scheduler with the specified set of fit predicates.
// All predicates must be true for the pod to be considered a fit.
func NewRandomFitSchedulerWithPredicates(podLister PodLister, random *rand.Rand, predicates []FitPredicate) Scheduler {
return &RandomFitScheduler{
podLister: podLister,
random: random,
predicates: predicates,
}
return NewGenericScheduler(predicates, evenPriority, podLister, random)
}
func podFitsPorts(pod api.Pod, existingPods []api.Pod, node string) (bool, error) {
@ -90,38 +76,3 @@ func MapPodsToMachines(lister PodLister) (map[string][]api.Pod, error) {
}
return machineToPods, nil
}
// Schedule schedules a pod on a random machine which matches its requirement.
func (s *RandomFitScheduler) Schedule(pod api.Pod, minionLister MinionLister) (string, error) {
machines, err := minionLister.List()
if err != nil {
return "", err
}
machineToPods, err := MapPodsToMachines(s.podLister)
if err != nil {
return "", err
}
var machineOptions []string
for _, machine := range machines {
podFits := true
for _, predicate := range s.predicates {
fits, err := predicate(pod, machineToPods[machine], machine)
if err != nil {
return "", err
}
if !fits {
podFits = false
break
}
}
if podFits {
machineOptions = append(machineOptions, machine)
}
}
if len(machineOptions) == 0 {
return "", fmt.Errorf("failed to find fit for %#v", pod)
}
s.randomLock.Lock()
defer s.randomLock.Unlock()
return machineOptions[s.random.Int()%len(machineOptions)], nil
}

43
pkg/scheduler/roundrobin.go
View File

@ -1,43 +0,0 @@
/*
Copyright 2014 Google Inc. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package scheduler
import (
"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
)
// RoundRobinScheduler chooses machines in order.
type RoundRobinScheduler struct {
currentIndex int
}
func NewRoundRobinScheduler() Scheduler {
return &RoundRobinScheduler{
currentIndex: -1,
}
}
// Schedule schedules a pod on the machine next to the last scheduled machine.
func (s *RoundRobinScheduler) Schedule(pod api.Pod, minionLister MinionLister) (string, error) {
machines, err := minionLister.List()
if err != nil {
return "", err
}
s.currentIndex = (s.currentIndex + 1) % len(machines)
result := machines[s.currentIndex]
return result, nil
}

35
pkg/scheduler/roundrobin_test.go
View File

@ -1,35 +0,0 @@
/*
Copyright 2014 Google Inc. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package scheduler
import (
"testing"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
)
func TestRoundRobinScheduler(t *testing.T) {
st := schedulerTester{
t: t,
scheduler: NewRoundRobinScheduler(),
minionLister: FakeMinionLister{"m1", "m2", "m3", "m4"},
}
st.expectSchedule(api.Pod{}, "m1")
st.expectSchedule(api.Pod{}, "m2")
st.expectSchedule(api.Pod{}, "m3")
st.expectSchedule(api.Pod{}, "m4")
}