Merge pull request #114 from DSFans2014/feat/sync-v0.19.0

sync nvidia/k8s-device-plugin v0.19.0

Author: hami-robot[bot]

README.md

@@ -135,9 +135,14 @@ You can set the sharing mode and customize your installation by adjusting the [c
 
 Once you have enabled this option on *all* the GPU nodes you wish to use,
 you can then enable GPU support in your cluster by deploying the following Daemonset:
+#### Normal Mode
 
 ```
-$ kubectl create -f volcano-vgpu-device-plugin.yml
+$ kubectl apply -f volcano-vgpu-device-plugin.yml
+```
+#### CDI Mode
+```
+$ kubectl apply -f volcano-vgpu-device-plugin-cdi.yml
 ```
 
 ### Verify environment is ready

api/config/v1/config.go

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2022, NVIDIA CORPORATION.  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 v1
+
+import (
+	"fmt"
+	"io"
+	"os"
+
+	cli "github.com/urfave/cli/v2"
+	"k8s.io/klog/v2"
+
+	"sigs.k8s.io/yaml"
+)
+
+// Version indicates the version of the 'Config' struct used to hold configuration information.
+const Version = "v1"
+
+// Config is a versioned struct used to hold configuration information.
+type Config struct {
+	Version   string    `json:"version"             yaml:"version"`
+	Flags     Flags     `json:"flags,omitempty"     yaml:"flags,omitempty"`
+	Resources Resources `json:"resources,omitempty" yaml:"resources,omitempty"`
+	Sharing   Sharing   `json:"sharing,omitempty"   yaml:"sharing,omitempty"`
+	Imex      Imex      `json:"imex,omitempty"      yaml:"imex,omitempty"`
+}
+
+// NewConfig builds out a Config struct from a config file (or command line flags).
+// The data stored in the config will be populated in order of precedence from
+// (1) command line, (2) environment variable, (3) config file.
+func NewConfig(c *cli.Context, flags []cli.Flag) (*Config, error) {
+	config := &Config{Version: Version}
+
+	if configFile := c.String("config-file"); configFile != "" {
+		var err error
+		config, err = parseConfig(configFile)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse config file: %v", err)
+		}
+	}
+
+	config.Flags.UpdateFromCLIFlags(c, flags)
+	// TODO: This is currently not at the flags level?
+	// Does this mean that we should move UpdateFromCLIFlags to function off Config?
+	if c.IsSet("imex-channel-ids") {
+		config.Imex.ChannelIDs = c.IntSlice("imex-channel-ids")
+	}
+	if c.IsSet("imex-required") {
+		config.Imex.Required = c.Bool("imex-required")
+	}
+
+	// If nvidiaDevRoot (the path to the device nodes on the host) is not set,
+	// we default to using the driver root on the host.
+	if config.Flags.NvidiaDevRoot == nil || *config.Flags.NvidiaDevRoot == "" {
+		config.Flags.NvidiaDevRoot = config.Flags.NvidiaDriverRoot
+	}
+
+	// We explicitly set sharing.mps.failRequestsGreaterThanOne = true
+	// This can be relaxed in certain cases -- such as a single GPU -- but
+	// requires additional logic around when it's OK to combine requests and
+	// makes the semantics of a request unclear.
+	if config.Sharing.MPS != nil {
+		config.Sharing.MPS.FailRequestsGreaterThanOne = true
+	}
+
+	return config, nil
+}
+
+// DisableResourceNamingInConfig temporarily disable the resource renaming feature of the plugin.
+// This may be reenabled in a future release.
+func DisableResourceNamingInConfig(config *Config) {
+	// Disable resource renaming through config.Resource
+	if len(config.Resources.GPUs) > 0 || len(config.Resources.MIGs) > 0 {
+		klog.Warning("Customizing the 'resources' field is not yet supported in the config. Ignoring...")
+	}
+	config.Resources.GPUs = nil
+	config.Resources.MIGs = nil
+
+	// Disable renaming / device selection in Sharing.TimeSlicing.Resources
+	config.Sharing.TimeSlicing.disableResoureRenaming("timeSlicing")
+	// Disable renaming / device selection in Sharing.MPS.Resources
+	config.Sharing.MPS.disableResoureRenaming("mps")
+}
+
+// parseConfig parses a config file as either YAML of JSON and unmarshals it into a Config struct.
+func parseConfig(configFile string) (*Config, error) {
+	reader, err := os.Open(configFile)
+	if err != nil {
+		return nil, fmt.Errorf("error opening config file: %v", err)
+	}
+	defer reader.Close()
+
+	config, err := parseConfigFrom(reader)
+	if err != nil {
+		return nil, fmt.Errorf("error parsing config file: %v", err)
+	}
+
+	return config, nil
+}
+
+func parseConfigFrom(reader io.Reader) (*Config, error) {
+	var err error
+	var configYaml []byte
+
+	configYaml, err = io.ReadAll(reader)
+	if err != nil {
+		return nil, fmt.Errorf("read error: %v", err)
+	}
+
+	var config Config
+	err = yaml.Unmarshal(configYaml, &config)
+	if err != nil {
+		return nil, fmt.Errorf("unmarshal error: %v", err)
+	}
+
+	if config.Version == "" {
+		config.Version = Version
+	}
+
+	if config.Version != Version {
+		return nil, fmt.Errorf("unknown version: %v", config.Version)
+	}
+
+	return &config, nil
+}

api/config/v1/consts.go

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2022, NVIDIA CORPORATION.  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 v1
+
+import (
+	cdiapi "tags.cncf.io/container-device-interface/pkg/cdi"
+)
+
+// Constants related to resource names
+const (
+	ResourceNamePrefix = "volcano.sh"
+	// ResourceNamePrefix              = "nvidia.com"
+	DefaultSharedResourceNameSuffix = ".shared"
+	MaxResourceNameLength           = 63
+)
+
+// Constants representing the various MIG strategies
+const (
+	MigStrategyNone   = "none"
+	MigStrategySingle = "single"
+	MigStrategyMixed  = "mixed"
+)
+
+// Constants to represent the various device list strategies
+const (
+	DeviceListStrategyEnvVar         = "envvar"
+	DeviceListStrategyVolumeMounts   = "volume-mounts"
+	DeviceListStrategyCDIAnnotations = "cdi-annotations"
+	DeviceListStrategyCDICRI         = "cdi-cri"
+)
+
+// Constants to represent the various device id strategies
+const (
+	DeviceIDStrategyUUID  = "uuid"
+	DeviceIDStrategyIndex = "index"
+)
+
+// Constants related to generating CDI specifications
+const (
+	DefaultCDIAnnotationPrefix = cdiapi.AnnotationPrefix
+	DefaultNvidiaCTKPath       = "/usr/bin/nvidia-ctk"
+	DefaultContainerDriverRoot = "/driver-root"
+)

api/config/v1/duration.go

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2022, NVIDIA CORPORATION.  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 v1
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"time"
+)
+
+// Duration wraps a time.Duration function with custom JSON marshaling/unmarshaling
+type Duration time.Duration
+
+// IsInfinite returns true if the duration represents an infinite sleep interval.
+func (d *Duration) IsInfinite() bool {
+	return d != nil && time.Duration(*d) == math.MaxInt64
+}
+
+// String returns a human-readable representation of the duration.
+func (d Duration) String() string {
+	if d.IsInfinite() {
+		return "infinite"
+	}
+	return time.Duration(d).String()
+}
+
+// MarshalJSON marshals 'Duration' to its raw bytes representation
+func (d Duration) MarshalJSON() ([]byte, error) {
+	return json.Marshal(d.String())
+}
+
+// UnmarshalJSON unmarshals raw bytes into a 'Duration' type.
+func (d *Duration) UnmarshalJSON(b []byte) error {
+	var v interface{}
+	if err := json.Unmarshal(b, &v); err != nil {
+		return err
+	}
+	switch value := v.(type) {
+	case float64:
+		*d = Duration(time.Duration(value))
+		return nil
+	case string:
+		return d.parse(value)
+	default:
+		return fmt.Errorf("invalid duration")
+	}
+}
+
+// parse parses a duration string, handling the special "infinite" value.
+func (d *Duration) parse(value string) error {
+	if value == "infinite" {
+		*d = Duration(math.MaxInt64)
+		return nil
+	}
+	parsed, err := time.ParseDuration(value)
+	if err != nil {
+		return err
+	}
+	*d = Duration(parsed)
+	return nil
+}
+
+// DurationValue implements cli.Generic for parsing duration flags with "infinite" support
+type DurationValue struct {
+	Value *Duration
+}
+
+// NewDurationValue creates a new DurationValue with the given default duration
+func NewDurationValue(d time.Duration) *DurationValue {
+	duration := Duration(d)
+	return &DurationValue{Value: &duration}
+}
+
+// Set implements cli.Generic
+func (d *DurationValue) Set(value string) error {
+	return d.Value.parse(value)
+}
+
+// String implements cli.Generic
+func (d *DurationValue) String() string {
+	if d.Value == nil {
+		return ""
+	}
+	if d.Value.IsInfinite() {
+		return "infinite"
+	}
+	return time.Duration(*d.Value).String()
+}