volcano.sh/volcano@v1.9.0/pkg/scheduler/plugins/numaaware/policy/policy_restricted_test.go (about)

     1  /*
     2  Copyright 2021 The Volcano Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package policy
    18  
    19  import (
    20  	"reflect"
    21  	"testing"
    22  
    23  	"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask"
    24  )
    25  
    26  func Test_restricted_predicate(t *testing.T) {
    27  	teseCases := []struct {
    28  		name           string
    29  		providersHints []map[string][]TopologyHint
    30  		expect         TopologyHint
    31  	}{
    32  		{
    33  			name: "test-1",
    34  			providersHints: []map[string][]TopologyHint{
    35  				{
    36  					"cpu": []TopologyHint{
    37  						{
    38  							NUMANodeAffinity: func() bitmask.BitMask {
    39  								mask, _ := bitmask.NewBitMask(0, 1)
    40  								return mask
    41  							}(),
    42  							Preferred: false,
    43  						},
    44  						{
    45  							NUMANodeAffinity: func() bitmask.BitMask {
    46  								mask, _ := bitmask.NewBitMask(0)
    47  								return mask
    48  							}(),
    49  							Preferred: true,
    50  						},
    51  					},
    52  				},
    53  				{
    54  					"gpu": []TopologyHint{
    55  						{
    56  							NUMANodeAffinity: func() bitmask.BitMask {
    57  								mask, _ := bitmask.NewBitMask(0, 1)
    58  								return mask
    59  							}(),
    60  							Preferred: false,
    61  						},
    62  						{
    63  							NUMANodeAffinity: func() bitmask.BitMask {
    64  								mask, _ := bitmask.NewBitMask(0)
    65  								return mask
    66  							}(),
    67  							Preferred: true,
    68  						},
    69  					},
    70  				},
    71  			},
    72  			expect: TopologyHint{
    73  				NUMANodeAffinity: func() bitmask.BitMask {
    74  					mask, _ := bitmask.NewBitMask(0)
    75  					return mask
    76  				}(),
    77  				Preferred: true,
    78  			},
    79  		},
    80  		{
    81  			name: "test-2",
    82  			providersHints: []map[string][]TopologyHint{
    83  				{
    84  					"cpu": []TopologyHint{
    85  						{
    86  							NUMANodeAffinity: func() bitmask.BitMask {
    87  								mask, _ := bitmask.NewBitMask(0, 1)
    88  								return mask
    89  							}(),
    90  							Preferred: false,
    91  						},
    92  						{
    93  							NUMANodeAffinity: func() bitmask.BitMask {
    94  								mask, _ := bitmask.NewBitMask(1)
    95  								return mask
    96  							}(),
    97  							Preferred: true,
    98  						},
    99  					},
   100  				},
   101  				{
   102  					"gpu": []TopologyHint{
   103  						{
   104  							NUMANodeAffinity: func() bitmask.BitMask {
   105  								mask, _ := bitmask.NewBitMask(0, 1)
   106  								return mask
   107  							}(),
   108  							Preferred: false,
   109  						},
   110  						{
   111  							NUMANodeAffinity: func() bitmask.BitMask {
   112  								mask, _ := bitmask.NewBitMask(1)
   113  								return mask
   114  							}(),
   115  							Preferred: true,
   116  						},
   117  					},
   118  				},
   119  			},
   120  			expect: TopologyHint{
   121  				NUMANodeAffinity: func() bitmask.BitMask {
   122  					mask, _ := bitmask.NewBitMask(1)
   123  					return mask
   124  				}(),
   125  				Preferred: true,
   126  			},
   127  		},
   128  		{
   129  			name: "test-3",
   130  			providersHints: []map[string][]TopologyHint{
   131  				{
   132  					"cpu": []TopologyHint{
   133  						{
   134  							NUMANodeAffinity: func() bitmask.BitMask {
   135  								mask, _ := bitmask.NewBitMask(0, 1)
   136  								return mask
   137  							}(),
   138  							Preferred: false,
   139  						},
   140  						{
   141  							NUMANodeAffinity: func() bitmask.BitMask {
   142  								mask, _ := bitmask.NewBitMask(0)
   143  								return mask
   144  							}(),
   145  							Preferred: true,
   146  						},
   147  						{
   148  							NUMANodeAffinity: func() bitmask.BitMask {
   149  								mask, _ := bitmask.NewBitMask(1)
   150  								return mask
   151  							}(),
   152  							Preferred: true,
   153  						},
   154  					},
   155  				},
   156  				{
   157  					"gpu": []TopologyHint{
   158  						{
   159  							NUMANodeAffinity: func() bitmask.BitMask {
   160  								mask, _ := bitmask.NewBitMask(0, 1)
   161  								return mask
   162  							}(),
   163  							Preferred: false,
   164  						},
   165  						{
   166  							NUMANodeAffinity: func() bitmask.BitMask {
   167  								mask, _ := bitmask.NewBitMask(0)
   168  								return mask
   169  							}(),
   170  							Preferred: true,
   171  						},
   172  						{
   173  							NUMANodeAffinity: func() bitmask.BitMask {
   174  								mask, _ := bitmask.NewBitMask(1)
   175  								return mask
   176  							}(),
   177  							Preferred: true,
   178  						},
   179  					},
   180  				},
   181  			},
   182  			expect: TopologyHint{
   183  				NUMANodeAffinity: func() bitmask.BitMask {
   184  					mask, _ := bitmask.NewBitMask(0)
   185  					return mask
   186  				}(),
   187  				Preferred: true,
   188  			},
   189  		},
   190  		{
   191  			name: "test-4",
   192  			providersHints: []map[string][]TopologyHint{
   193  				{
   194  					"cpu": []TopologyHint{
   195  						{
   196  							NUMANodeAffinity: func() bitmask.BitMask {
   197  								mask, _ := bitmask.NewBitMask(0, 1)
   198  								return mask
   199  							}(),
   200  							Preferred: false,
   201  						},
   202  						{
   203  							NUMANodeAffinity: func() bitmask.BitMask {
   204  								mask, _ := bitmask.NewBitMask(0)
   205  								return mask
   206  							}(),
   207  							Preferred: true,
   208  						},
   209  					},
   210  				},
   211  				{
   212  					"gpu": []TopologyHint{
   213  						{
   214  							NUMANodeAffinity: func() bitmask.BitMask {
   215  								mask, _ := bitmask.NewBitMask(0, 1)
   216  								return mask
   217  							}(),
   218  							Preferred: false,
   219  						},
   220  						{
   221  							NUMANodeAffinity: func() bitmask.BitMask {
   222  								mask, _ := bitmask.NewBitMask(1)
   223  								return mask
   224  							}(),
   225  							Preferred: true,
   226  						},
   227  					},
   228  				},
   229  			},
   230  			expect: TopologyHint{
   231  				NUMANodeAffinity: func() bitmask.BitMask {
   232  					mask, _ := bitmask.NewBitMask(0)
   233  					return mask
   234  				}(),
   235  				Preferred: false,
   236  			},
   237  		},
   238  		{
   239  			name: "test-5",
   240  			providersHints: []map[string][]TopologyHint{
   241  				{
   242  					"cpu": []TopologyHint{
   243  						{
   244  							NUMANodeAffinity: func() bitmask.BitMask {
   245  								mask, _ := bitmask.NewBitMask(0, 1)
   246  								return mask
   247  							}(),
   248  							Preferred: false,
   249  						},
   250  						{
   251  							NUMANodeAffinity: func() bitmask.BitMask {
   252  								mask, _ := bitmask.NewBitMask(0)
   253  								return mask
   254  							}(),
   255  							Preferred: true,
   256  						},
   257  					},
   258  				},
   259  				{
   260  					"gpu": []TopologyHint{
   261  						{
   262  							NUMANodeAffinity: func() bitmask.BitMask {
   263  								mask, _ := bitmask.NewBitMask(0, 1)
   264  								return mask
   265  							}(),
   266  							Preferred: true,
   267  						},
   268  					},
   269  				},
   270  			},
   271  			expect: TopologyHint{
   272  				NUMANodeAffinity: func() bitmask.BitMask {
   273  					mask, _ := bitmask.NewBitMask(0)
   274  					return mask
   275  				}(),
   276  				Preferred: true,
   277  			},
   278  		},
   279  		{
   280  			name: "test-6",
   281  			providersHints: []map[string][]TopologyHint{
   282  				{
   283  					"cpu": []TopologyHint{
   284  						{
   285  							NUMANodeAffinity: func() bitmask.BitMask {
   286  								mask, _ := bitmask.NewBitMask(0, 1)
   287  								return mask
   288  							}(),
   289  							Preferred: true,
   290  						},
   291  					},
   292  				},
   293  				{
   294  					"gpu": []TopologyHint{
   295  						{
   296  							NUMANodeAffinity: func() bitmask.BitMask {
   297  								mask, _ := bitmask.NewBitMask(0, 1)
   298  								return mask
   299  							}(),
   300  							Preferred: true,
   301  						},
   302  					},
   303  				},
   304  			},
   305  			expect: TopologyHint{
   306  				NUMANodeAffinity: func() bitmask.BitMask {
   307  					mask, _ := bitmask.NewBitMask(0, 1)
   308  					return mask
   309  				}(),
   310  				Preferred: true,
   311  			},
   312  		},
   313  	}
   314  
   315  	for _, testcase := range teseCases {
   316  		policy := NewPolicyRestricted([]int{0, 1})
   317  		bestHit, _ := policy.Predicate(testcase.providersHints)
   318  		if !reflect.DeepEqual(bestHit, testcase.expect) {
   319  			t.Errorf("%s failed, expect %v, bestHit= %v\n", testcase.name, testcase.expect, bestHit)
   320  		}
   321  	}
   322  }