From c19073cdf1314ecaffa45f689becffb57bc5bfea Mon Sep 17 00:00:00 2001 From: zhitianli Date: Sun, 28 Jul 2024 16:46:59 +0800 Subject: [PATCH 1/3] add vgpu monitor container to be able to collect vgpu related metrics on nodes --- cmd/vGPUmonitor/build.sh | 17 + cmd/vGPUmonitor/cudevshr.go | 151 +++++ cmd/vGPUmonitor/feedback.go | 281 ++++++++++ cmd/vGPUmonitor/main.go | 36 ++ cmd/vGPUmonitor/metrics.go | 318 +++++++++++ cmd/vGPUmonitor/noderpc/noderpc.pb.go | 518 ++++++++++++++++++ cmd/vGPUmonitor/noderpc/noderpc.proto | 61 +++ cmd/vGPUmonitor/noderpc/noderpc_grpc.pb.go | 103 ++++ cmd/vGPUmonitor/pathmonitor.go | 176 ++++++ cmd/vGPUmonitor/pathmonitor_test.go | 61 +++ cmd/vGPUmonitor/testcollector/main.go | 145 +++++ cmd/vGPUmonitor/validation.go | 37 ++ .../amd64/Dockerfile.vgpu-monitor-ubuntu20.04 | 20 + go.mod | 47 +- go.sum | 41 +- volcano-vgpu-device-plugin.yml | 65 ++- 16 files changed, 2045 insertions(+), 32 deletions(-) create mode 100644 cmd/vGPUmonitor/build.sh create mode 100644 cmd/vGPUmonitor/cudevshr.go create mode 100644 cmd/vGPUmonitor/feedback.go create mode 100644 cmd/vGPUmonitor/main.go create mode 100644 cmd/vGPUmonitor/metrics.go create mode 100644 cmd/vGPUmonitor/noderpc/noderpc.pb.go create mode 100644 cmd/vGPUmonitor/noderpc/noderpc.proto create mode 100644 cmd/vGPUmonitor/noderpc/noderpc_grpc.pb.go create mode 100644 cmd/vGPUmonitor/pathmonitor.go create mode 100644 cmd/vGPUmonitor/pathmonitor_test.go create mode 100644 cmd/vGPUmonitor/testcollector/main.go create mode 100644 cmd/vGPUmonitor/validation.go create mode 100644 docker/amd64/Dockerfile.vgpu-monitor-ubuntu20.04 diff --git a/cmd/vGPUmonitor/build.sh b/cmd/vGPUmonitor/build.sh new file mode 100644 index 0000000..c6bfa72 --- /dev/null +++ b/cmd/vGPUmonitor/build.sh @@ -0,0 +1,17 @@ +#!/usr/bin/env bash +# Copyright 2024 The HAMi Authors. +# +# 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. + +protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative noderpc/noderpc.proto +go build diff --git a/cmd/vGPUmonitor/cudevshr.go b/cmd/vGPUmonitor/cudevshr.go new file mode 100644 index 0000000..e859b31 --- /dev/null +++ b/cmd/vGPUmonitor/cudevshr.go @@ -0,0 +1,151 @@ +/* +Copyright 2024 The HAMi Authors. + +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 main + +import ( + "bytes" + "encoding/binary" + "errors" + "fmt" + "os" + "syscall" + "unsafe" + + "golang.org/x/exp/mmap" +) + +const maxDevices = 16 + +type deviceMemory struct { + contextSize uint64 + moduleSize uint64 + bufferSize uint64 + offset uint64 + total uint64 +} + +type shrregProcSlotT struct { + pid int32 + hostpid int32 + used [16]deviceMemory + monitorused [16]uint64 + status int32 +} + +type uuid struct { + uuid [96]byte +} + +type semT struct { + sem [32]byte +} + +type sharedRegionT struct { + initializedFlag int32 + smInitFlag int32 + ownerPid uint32 + sem semT + num uint64 + uuids [16]uuid + + limit [16]uint64 + smLimit [16]uint64 + procs [1024]shrregProcSlotT + + procnum int32 + utilizationSwitch int32 + recentKernel int32 + priority int32 +} + +type SharedRegionInfoT struct { + pid int32 + fd int32 + initStatus int16 + sharedRegion sharedRegionT +} + +type nvidiaCollector struct { + // Exposed for testing + cudevshrPath string + at *mmap.ReaderAt + cudaCache *sharedRegionT +} + +func setProcSlot(offset int64, at *mmap.ReaderAt) (shrregProcSlotT, error) { + temp := shrregProcSlotT{} + buff := make([]byte, 4) + at.ReadAt(buff, offset) + bytesbuffer := bytes.NewBuffer(buff) + binary.Read(bytesbuffer, binary.LittleEndian, &temp.pid) + var monitorused uint64 + //fmt.Println("pid==", temp.pid, "buff=", buff) + buff = make([]byte, 8) + for i := 0; i < maxDevices; i++ { + at.ReadAt(buff, offset+8+8*int64(i)) + bytesbuffer = bytes.NewBuffer(buff) + binary.Read(bytesbuffer, binary.LittleEndian, &temp.used[i]) + } + for i := 0; i < maxDevices; i++ { + at.ReadAt(buff, offset+8+8*16+8*int64(i)) + bytesbuffer = bytes.NewBuffer(buff) + binary.Read(bytesbuffer, binary.LittleEndian, &monitorused) + if monitorused > temp.used[i].total { + temp.used[i].total = monitorused + } + } + return temp, nil +} + +func getDeviceUsedMemory(idx int, sharedregion sharedRegionT) (uint64, error) { + var sum uint64 + sum = 0 + if idx < 0 || idx > 16 { + return 0, errors.New("out of device idx") + } + for _, val := range sharedregion.procs { + sum += val.used[idx].total + } + return sum, nil +} + +func mmapcachefile(filename string, nc *nvidiaCollector) error { + var m = &sharedRegionT{} + f, err := os.OpenFile(filename, os.O_RDWR, 0666) + if err != nil { + fmt.Println("openfile error=", err.Error()) + return err + } + data, err := syscall.Mmap(int(f.Fd()), 0, int(unsafe.Sizeof(*m)), syscall.PROT_WRITE|syscall.PROT_READ, syscall.MAP_SHARED) + if err != nil { + return err + } + var cachestr *sharedRegionT = *(**sharedRegionT)(unsafe.Pointer(&data)) + fmt.Println("sizeof=", unsafe.Sizeof(*m), "cachestr=", cachestr.utilizationSwitch, cachestr.recentKernel) + nc.cudaCache = cachestr + return nil +} + +func getvGPUMemoryInfo(nc *nvidiaCollector) (*sharedRegionT, error) { + if len(nc.cudevshrPath) > 0 { + if nc.cudaCache == nil { + mmapcachefile(nc.cudevshrPath, nc) + } + return nc.cudaCache, nil + } + return &sharedRegionT{}, errors.New("not found path") +} diff --git a/cmd/vGPUmonitor/feedback.go b/cmd/vGPUmonitor/feedback.go new file mode 100644 index 0000000..56dda7d --- /dev/null +++ b/cmd/vGPUmonitor/feedback.go @@ -0,0 +1,281 @@ +/* +Copyright 2024 The HAMi Authors. + +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 main + +import ( + "errors" + "fmt" + "os" + "sort" + "strconv" + "strings" + "sync" + "time" + + "github.com/NVIDIA/go-nvml/pkg/nvml" + corev1 "k8s.io/api/core/v1" + "k8s.io/klog/v2" +) + +var cgroupDriver int + +type hostGPUPid struct { + hostGPUPid int + mtime uint64 +} + +type UtilizationPerDevice []int + +var mutex sync.Mutex +var srPodList map[string]podusage + +func init() { + srPodList = make(map[string]podusage) +} + +func setcGgroupDriver() int { + // 1 for cgroupfs 2 for systemd + kubeletconfig, err := os.ReadFile("/hostvar/lib/kubelet/config.yaml") + if err != nil { + return 0 + } + content := string(kubeletconfig) + pos := strings.LastIndex(content, "cgroupDriver:") + if pos < 0 { + return 0 + } + if strings.Contains(content, "systemd") { + return 2 + } + if strings.Contains(content, "cgroupfs") { + return 1 + } + return 0 +} + +func getUsedGPUPid() ([]uint, nvml.Return) { + tmp := []nvml.ProcessInfo{} + count, err := nvml.DeviceGetCount() + if err != nvml.SUCCESS { + return []uint{}, err + } + for i := 0; i < count; i++ { + device, err := nvml.DeviceGetHandleByIndex(i) + if err != nvml.SUCCESS { + return []uint{}, err + } + ids, err := device.GetComputeRunningProcesses() + if err != nvml.SUCCESS { + return []uint{}, err + } + tmp = append(tmp, ids...) + } + result := make([]uint, 0) + m := make(map[uint]bool) + for _, v := range tmp { + if _, ok := m[uint(v.Pid)]; !ok { + result = append(result, uint(v.Pid)) + m[uint(v.Pid)] = true + } + } + sort.Slice(tmp, func(i, j int) bool { return tmp[i].Pid > tmp[j].Pid }) + return result, nvml.SUCCESS +} + +func setHostPid(pod corev1.Pod, ctr corev1.ContainerStatus, sr *podusage) error { + var pids []string + mutex.Lock() + defer mutex.Unlock() + + if cgroupDriver == 0 { + cgroupDriver = setcGgroupDriver() + } + if cgroupDriver == 0 { + return errors.New("can not identify cgroup driver") + } + usedGPUArray, err := getUsedGPUPid() + if err != nvml.SUCCESS { + return errors.New("get usedGPUID failed, ret:" + nvml.ErrorString(err)) + } + if len(usedGPUArray) == 0 { + return nil + } + qos := strings.ToLower(string(pod.Status.QOSClass)) + var filename string + if cgroupDriver == 1 { + /* Cgroupfs */ + filename = fmt.Sprintf("/sysinfo/fs/cgroup/memory/kubepods/%s/pod%s/%s/tasks", qos, pod.UID, strings.TrimPrefix(ctr.ContainerID, "docker://")) + } + if cgroupDriver == 2 { + /* Systemd */ + cgroupuid := strings.ReplaceAll(string(pod.UID), "-", "_") + filename = fmt.Sprintf("/sysinfo/fs/cgroup/systemd/kubepods.slice/kubepods-%s.slice/kubepods-%s-pod%s.slice/docker-%s.scope/tasks", qos, qos, cgroupuid, strings.TrimPrefix(ctr.ContainerID, "docker://")) + } + fmt.Println("filename=", filename) + content, ferr := os.ReadFile(filename) + if ferr != nil { + return ferr + } + pids = strings.Split(string(content), "\n") + hostPidArray := []hostGPUPid{} + for _, val := range pids { + tmp, _ := strconv.Atoi(val) + if tmp != 0 { + var stat os.FileInfo + var err error + if stat, err = os.Lstat(fmt.Sprintf("/proc/%v", tmp)); err != nil { + return err + } + mtime := stat.ModTime().Unix() + hostPidArray = append(hostPidArray, hostGPUPid{ + hostGPUPid: tmp, + mtime: uint64(mtime), + }) + } + } + usedGPUHostArray := []hostGPUPid{} + for _, val := range usedGPUArray { + for _, hostpid := range hostPidArray { + if uint(hostpid.hostGPUPid) == val { + usedGPUHostArray = append(usedGPUHostArray, hostpid) + } + } + } + //fmt.Println("usedHostGPUArray=", usedGPUHostArray) + sort.Slice(usedGPUHostArray, func(i, j int) bool { return usedGPUHostArray[i].mtime > usedGPUHostArray[j].mtime }) + if sr == nil || sr.sr == nil { + return nil + } + for idx, val := range sr.sr.procs { + //fmt.Println("pid=", val.pid) + if val.pid == 0 { + break + } + if idx < len(usedGPUHostArray) { + if val.hostpid == 0 || val.hostpid != int32(usedGPUHostArray[idx].hostGPUPid) { + fmt.Println("Assign host pid to pid instead", usedGPUHostArray[idx].hostGPUPid, val.pid, val.hostpid) + sr.sr.procs[idx].hostpid = int32(usedGPUHostArray[idx].hostGPUPid) + fmt.Println("val=", val.hostpid, sr.sr.procs[idx].hostpid) + } + } + } + return nil + +} + +func CheckBlocking(utSwitchOn map[string]UtilizationPerDevice, p int, pu podusage) bool { + for _, devuuid := range pu.sr.uuids { + _, ok := utSwitchOn[string(devuuid.uuid[:])] + if ok { + for i := 0; i < p; i++ { + if utSwitchOn[string(devuuid.uuid[:])][i] > 0 { + return true + } + } + return false + } + } + return false +} + +// Check whether task with higher priority use GPU or there are other tasks with the same priority. +func CheckPriority(utSwitchOn map[string]UtilizationPerDevice, p int, pu podusage) bool { + for _, devuuid := range pu.sr.uuids { + _, ok := utSwitchOn[string(devuuid.uuid[:])] + if ok { + for i := 0; i < p; i++ { + if utSwitchOn[string(devuuid.uuid[:])][i] > 0 { + return true + } + } + if utSwitchOn[string(devuuid.uuid[:])][p] > 1 { + return true + } + } + } + return false +} + +func Observe(srlist *map[string]podusage) error { + utSwitchOn := map[string]UtilizationPerDevice{} + + for idx, val := range *srlist { + if val.sr == nil { + continue + } + if val.sr.recentKernel > 0 { + (*srlist)[idx].sr.recentKernel-- + if (*srlist)[idx].sr.recentKernel > 0 { + for _, devuuid := range val.sr.uuids { + // Null device condition + if devuuid.uuid[0] == 0 { + continue + } + if len(utSwitchOn[string(devuuid.uuid[:])]) == 0 { + utSwitchOn[string(devuuid.uuid[:])] = []int{0, 0} + } + utSwitchOn[string(devuuid.uuid[:])][val.sr.priority]++ + } + } + } + } + for idx, val := range *srlist { + if val.sr == nil { + continue + } + if CheckBlocking(utSwitchOn, int(val.sr.priority), val) { + if (*srlist)[idx].sr.recentKernel >= 0 { + klog.Infof("utSwitchon=%v", utSwitchOn) + klog.Infof("Setting Blocking to on %v", idx) + (*srlist)[idx].sr.recentKernel = -1 + } + } else { + if (*srlist)[idx].sr.recentKernel < 0 { + klog.Infof("utSwitchon=%v", utSwitchOn) + klog.Infof("Setting Blocking to off %v", idx) + (*srlist)[idx].sr.recentKernel = 0 + } + } + if CheckPriority(utSwitchOn, int(val.sr.priority), val) { + if (*srlist)[idx].sr.utilizationSwitch != 1 { + klog.Infof("utSwitchon=%v", utSwitchOn) + klog.Infof("Setting UtilizationSwitch to on %v", idx) + (*srlist)[idx].sr.utilizationSwitch = 1 + } + } else { + if (*srlist)[idx].sr.utilizationSwitch != 0 { + klog.Infof("utSwitchon=%v", utSwitchOn) + klog.Infof("Setting UtilizationSwitch to off %v", idx) + (*srlist)[idx].sr.utilizationSwitch = 0 + } + } + } + return nil +} + +func watchAndFeedback() { + nvml.Init() + for { + time.Sleep(time.Second * 5) + err := monitorPath(srPodList) + if err != nil { + klog.Errorf("monitorPath failed %v", err.Error()) + } + klog.Infof("WatchAndFeedback srPodList=%v", srPodList) + Observe(&srPodList) + } +} diff --git a/cmd/vGPUmonitor/main.go b/cmd/vGPUmonitor/main.go new file mode 100644 index 0000000..dbac560 --- /dev/null +++ b/cmd/vGPUmonitor/main.go @@ -0,0 +1,36 @@ +/* +Copyright 2024 The HAMi Authors. + +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 main + +import ( + "k8s.io/klog/v2" +) + +func main() { + if err := ValidateEnvVars(); err != nil { + klog.Fatalf("Failed to validate environment variables: %v", err) + } + cgroupDriver = 0 + errchannel := make(chan error) + go serveInfo(errchannel) + go initMetrics() + go watchAndFeedback() + for { + err := <-errchannel + klog.Errorf("failed to serve: %v", err) + } +} diff --git a/cmd/vGPUmonitor/metrics.go b/cmd/vGPUmonitor/metrics.go new file mode 100644 index 0000000..47d5aef --- /dev/null +++ b/cmd/vGPUmonitor/metrics.go @@ -0,0 +1,318 @@ +/* +Copyright 2024 The HAMi Authors. + +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 main + +import ( + "errors" + "fmt" + "log" + "net/http" + "strings" + "time" + + "github.com/NVIDIA/go-nvml/pkg/nvml" + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/promhttp" + + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/informers" + "k8s.io/client-go/kubernetes" + listerscorev1 "k8s.io/client-go/listers/core/v1" + "k8s.io/client-go/rest" + "k8s.io/klog/v2" +) + +// ClusterManager is an example for a system that might have been built without +// Prometheus in mind. It models a central manager of jobs running in a +// cluster. Thus, we implement a custom Collector called +// ClusterManagerCollector, which collects information from a ClusterManager +// using its provided methods and turns them into Prometheus Metrics for +// collection. +// +// An additional challenge is that multiple instances of the ClusterManager are +// run within the same binary, each in charge of a different zone. We need to +// make use of wrapping Registerers to be able to register each +// ClusterManagerCollector instance with Prometheus. +type ClusterManager struct { + Zone string + // Contains many more fields not listed in this example. + PodLister listerscorev1.PodLister +} + +// ReallyExpensiveAssessmentOfTheSystemState is a mock for the data gathering a +// real cluster manager would have to do. Since it may actually be really +// expensive, it must only be called once per collection. This implementation, +// obviously, only returns some made-up data. +func (c *ClusterManager) ReallyExpensiveAssessmentOfTheSystemState() ( + oomCountByHost map[string]int, ramUsageByHost map[string]float64, +) { + // Just example fake data. + oomCountByHost = map[string]int{ + "foo.example.org": 42, + "bar.example.org": 2001, + } + ramUsageByHost = map[string]float64{ + "foo.example.org": 6.023e23, + "bar.example.org": 3.14, + } + return +} + +// ClusterManagerCollector implements the Collector interface. +type ClusterManagerCollector struct { + ClusterManager *ClusterManager +} + +// Descriptors used by the ClusterManagerCollector below. +var ( + hostGPUdesc = prometheus.NewDesc( + "HostGPUMemoryUsage", + "GPU device memory usage", + []string{"deviceidx", "deviceuuid"}, nil, + ) + + hostGPUUtilizationdesc = prometheus.NewDesc( + "HostCoreUtilization", + "GPU core utilization", + []string{"deviceidx", "deviceuuid"}, nil, + ) + + ctrvGPUdesc = prometheus.NewDesc( + "vGPU_device_memory_usage_in_bytes", + "vGPU device usage", + []string{"podnamespace", "podname", "ctrname", "vdeviceid", "deviceuuid"}, nil, + ) + + ctrvGPUlimitdesc = prometheus.NewDesc( + "vGPU_device_memory_limit_in_bytes", + "vGPU device limit", + []string{"podnamespace", "podname", "ctrname", "vdeviceid", "deviceuuid"}, nil, + ) + ctrDeviceMemorydesc = prometheus.NewDesc( + "Device_memory_desc_of_container", + "Container device meory description", + []string{"podnamespace", "podname", "ctrname", "vdeviceid", "deviceuuid", "context", "module", "data", "offset"}, nil, + ) + clientset *kubernetes.Clientset +) + +// Describe is implemented with DescribeByCollect. That's possible because the +// Collect method will always return the same two metrics with the same two +// descriptors. +func (cc ClusterManagerCollector) Describe(ch chan<- *prometheus.Desc) { + ch <- hostGPUdesc + ch <- ctrvGPUdesc + ch <- ctrvGPUlimitdesc + ch <- hostGPUUtilizationdesc + //prometheus.DescribeByCollect(cc, ch) +} + +func parseidstr(podusage string) (string, string, error) { + tmp := strings.Split(podusage, "_") + if len(tmp) > 1 { + return tmp[0], tmp[1], nil + } else { + return "", "", errors.New("parse error") + } +} + +func gettotalusage(usage podusage, vidx int) (deviceMemory, error) { + added := deviceMemory{ + bufferSize: 0, + contextSize: 0, + moduleSize: 0, + offset: 0, + total: 0, + } + for _, val := range usage.sr.procs { + added.bufferSize += val.used[vidx].bufferSize + added.contextSize += val.used[vidx].contextSize + added.moduleSize += val.used[vidx].moduleSize + added.offset += val.used[vidx].offset + added.total += val.used[vidx].total + } + return added, nil +} + +func getsrlist() map[string]podusage { + return srPodList +} + +// Collect first triggers the ReallyExpensiveAssessmentOfTheSystemState. Then it +// creates constant metrics for each host on the fly based on the returned data. +// +// Note that Collect could be called concurrently, so we depend on +// ReallyExpensiveAssessmentOfTheSystemState to be concurrency-safe. +func (cc ClusterManagerCollector) Collect(ch chan<- prometheus.Metric) { + klog.Info("Starting to collect metrics for vGPUMonitor") + if srPodList == nil { + srPodList = make(map[string]podusage) + } + if err := monitorPath(srPodList); err != nil { + klog.Error("err=", err.Error()) + } + if clientset != nil { + nvret := nvml.Init() + if nvret != nvml.SUCCESS { + klog.Error("nvml Init err=", nvml.ErrorString(nvret)) + } + devnum, nvret := nvml.DeviceGetCount() + if nvret != nvml.SUCCESS { + klog.Error("nvml GetDeviceCount err=", nvml.ErrorString(nvret)) + } else { + for ii := 0; ii < devnum; ii++ { + hdev, nvret := nvml.DeviceGetHandleByIndex(ii) + if nvret != nvml.SUCCESS { + klog.Error(nvml.ErrorString(nvret)) + } + memoryUsed := 0 + memory, ret := hdev.GetMemoryInfo() + if ret == nvml.SUCCESS { + memoryUsed = int(memory.Used) + } else { + klog.Error("nvml get memory error ret=", ret) + } + + uuid, nvret := hdev.GetUUID() + if nvret != nvml.SUCCESS { + klog.Error(nvml.ErrorString(nvret)) + } else { + ch <- prometheus.MustNewConstMetric( + hostGPUdesc, + prometheus.GaugeValue, + float64(memoryUsed), + fmt.Sprint(ii), uuid, + ) + } + util, nvret := hdev.GetUtilizationRates() + if nvret != nvml.SUCCESS { + klog.Error(nvml.ErrorString(nvret)) + } else { + ch <- prometheus.MustNewConstMetric( + hostGPUUtilizationdesc, + prometheus.GaugeValue, + float64(util.Gpu), + fmt.Sprint(ii), uuid, + ) + } + + } + } + + pods, err := cc.ClusterManager.PodLister.List(labels.Everything()) + if err != nil { + klog.Error("failed to list pods with err=", err.Error()) + } + for _, val := range pods { + for sridx := range srPodList { + if srPodList[sridx].sr == nil { + continue + } + podUID := strings.Split(srPodList[sridx].idstr, "_")[0] + ctrName := strings.Split(srPodList[sridx].idstr, "_")[1] + if strings.Compare(string(val.UID), podUID) == 0 { + fmt.Println("Pod matched!", val.Name, val.Namespace, val.Labels) + for _, ctr := range val.Spec.Containers { + if strings.Compare(ctr.Name, ctrName) == 0 { + fmt.Println("container matched", ctr.Name) + //err := setHostPid(val, val.Status.ContainerStatuses[ctridx], &srPodList[sridx]) + //if err != nil { + // fmt.Println("setHostPid filed", err.Error()) + //} + //fmt.Println("sr.list=", srPodList[sridx].sr) + podlabels := make(map[string]string) + for idx, val := range val.Labels { + idxfix := strings.ReplaceAll(idx, "-", "_") + valfix := strings.ReplaceAll(val, "-", "_") + podlabels[idxfix] = valfix + } + for i := 0; i < int(srPodList[sridx].sr.num); i++ { + value, _ := gettotalusage(srPodList[sridx], i) + uuid := string(srPodList[sridx].sr.uuids[i].uuid[:])[0:40] + + //fmt.Println("uuid=", uuid, "length=", len(uuid)) + ch <- prometheus.MustNewConstMetric( + ctrvGPUdesc, + prometheus.GaugeValue, + float64(value.total), + val.Namespace, val.Name, ctrName, fmt.Sprint(i), uuid, /*,string(sr.sr.uuids[i].uuid[:])*/ + ) + ch <- prometheus.MustNewConstMetric( + ctrvGPUlimitdesc, + prometheus.GaugeValue, + float64(srPodList[sridx].sr.limit[i]), + val.Namespace, val.Name, ctrName, fmt.Sprint(i), uuid, /*,string(sr.sr.uuids[i].uuid[:])*/ + ) + ch <- prometheus.MustNewConstMetric( + ctrDeviceMemorydesc, + prometheus.CounterValue, + float64(value.total), + val.Namespace, val.Name, ctrName, fmt.Sprint(i), uuid, fmt.Sprint(value.contextSize), fmt.Sprint(value.moduleSize), fmt.Sprint(value.bufferSize), fmt.Sprint(value.offset), + ) + } + } + } + } + } + } + } +} + +// NewClusterManager first creates a Prometheus-ignorant ClusterManager +// instance. Then, it creates a ClusterManagerCollector for the just created +// ClusterManager. Finally, it registers the ClusterManagerCollector with a +// wrapping Registerer that adds the zone as a label. In this way, the metrics +// collected by different ClusterManagerCollectors do not collide. +func NewClusterManager(zone string, reg prometheus.Registerer) *ClusterManager { + c := &ClusterManager{ + Zone: zone, + } + + informerFactory := informers.NewSharedInformerFactoryWithOptions(clientset, time.Hour*1) + c.PodLister = informerFactory.Core().V1().Pods().Lister() + stopCh := make(chan struct{}) + informerFactory.Start(stopCh) + + cc := ClusterManagerCollector{ClusterManager: c} + prometheus.WrapRegistererWith(prometheus.Labels{"zone": zone}, reg).MustRegister(cc) + return c +} + +func initMetrics() { + // Since we are dealing with custom Collector implementations, it might + // be a good idea to try it out with a pedantic registry. + klog.Info("Initializing metrics for vGPUmonitor") + reg := prometheus.NewRegistry() + //reg := prometheus.NewPedanticRegistry() + config, err := rest.InClusterConfig() + if err != nil { + fmt.Println(err.Error()) + return + } + clientset, err = kubernetes.NewForConfig(config) + if err != nil { + fmt.Println(err.Error()) + return + } + + // Construct cluster managers. In real code, we would assign them to + // variables to then do something with them. + NewClusterManager("vGPU", reg) + + http.Handle("/metrics", promhttp.HandlerFor(reg, promhttp.HandlerOpts{})) + log.Fatal(http.ListenAndServe(":9394", nil)) +} diff --git a/cmd/vGPUmonitor/noderpc/noderpc.pb.go b/cmd/vGPUmonitor/noderpc/noderpc.pb.go new file mode 100644 index 0000000..4c732b8 --- /dev/null +++ b/cmd/vGPUmonitor/noderpc/noderpc.pb.go @@ -0,0 +1,518 @@ +// Copyright 2015 gRPC authors. +// +// 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. + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.1 +// protoc v3.14.0 +// source: noderpc/noderpc.proto + +package vGPUmonitor + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// The sharedProcs contains the sharedRegion +type ShrregProcSlotT struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Pid int32 `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"` + Used []uint64 `protobuf:"varint,2,rep,packed,name=used,proto3" json:"used,omitempty"` + Status int32 `protobuf:"varint,3,opt,name=status,proto3" json:"status,omitempty"` +} + +func (x *ShrregProcSlotT) Reset() { + *x = ShrregProcSlotT{} + if protoimpl.UnsafeEnabled { + mi := &file_noderpc_noderpc_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ShrregProcSlotT) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ShrregProcSlotT) ProtoMessage() {} + +func (x *ShrregProcSlotT) ProtoReflect() protoreflect.Message { + mi := &file_noderpc_noderpc_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ShrregProcSlotT.ProtoReflect.Descriptor instead. +func (*ShrregProcSlotT) Descriptor() ([]byte, []int) { + return file_noderpc_noderpc_proto_rawDescGZIP(), []int{0} +} + +func (x *ShrregProcSlotT) GetPid() int32 { + if x != nil { + return x.Pid + } + return 0 +} + +func (x *ShrregProcSlotT) GetUsed() []uint64 { + if x != nil { + return x.Used + } + return nil +} + +func (x *ShrregProcSlotT) GetStatus() int32 { + if x != nil { + return x.Status + } + return 0 +} + +// The sharedRegionT struct is the main struct for monitoring vgpu +type SharedRegionT struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + InitializedFlag int32 `protobuf:"varint,1,opt,name=initializedFlag,proto3" json:"initializedFlag,omitempty"` + OwnerPid uint32 `protobuf:"varint,2,opt,name=ownerPid,proto3" json:"ownerPid,omitempty"` + Sem uint32 `protobuf:"varint,3,opt,name=sem,proto3" json:"sem,omitempty"` + Limit []uint64 `protobuf:"varint,4,rep,packed,name=limit,proto3" json:"limit,omitempty"` + SmLimit []uint64 `protobuf:"varint,5,rep,packed,name=sm_limit,json=smLimit,proto3" json:"sm_limit,omitempty"` + Procs []*ShrregProcSlotT `protobuf:"bytes,6,rep,name=procs,proto3" json:"procs,omitempty"` +} + +func (x *SharedRegionT) Reset() { + *x = SharedRegionT{} + if protoimpl.UnsafeEnabled { + mi := &file_noderpc_noderpc_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SharedRegionT) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SharedRegionT) ProtoMessage() {} + +func (x *SharedRegionT) ProtoReflect() protoreflect.Message { + mi := &file_noderpc_noderpc_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SharedRegionT.ProtoReflect.Descriptor instead. +func (*SharedRegionT) Descriptor() ([]byte, []int) { + return file_noderpc_noderpc_proto_rawDescGZIP(), []int{1} +} + +func (x *SharedRegionT) GetInitializedFlag() int32 { + if x != nil { + return x.InitializedFlag + } + return 0 +} + +func (x *SharedRegionT) GetOwnerPid() uint32 { + if x != nil { + return x.OwnerPid + } + return 0 +} + +func (x *SharedRegionT) GetSem() uint32 { + if x != nil { + return x.Sem + } + return 0 +} + +func (x *SharedRegionT) GetLimit() []uint64 { + if x != nil { + return x.Limit + } + return nil +} + +func (x *SharedRegionT) GetSmLimit() []uint64 { + if x != nil { + return x.SmLimit + } + return nil +} + +func (x *SharedRegionT) GetProcs() []*ShrregProcSlotT { + if x != nil { + return x.Procs + } + return nil +} + +type Podusage struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Poduuid string `protobuf:"bytes,1,opt,name=poduuid,proto3" json:"poduuid,omitempty"` + Podvgpuinfo *SharedRegionT `protobuf:"bytes,2,opt,name=podvgpuinfo,proto3" json:"podvgpuinfo,omitempty"` +} + +func (x *Podusage) Reset() { + *x = Podusage{} + if protoimpl.UnsafeEnabled { + mi := &file_noderpc_noderpc_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Podusage) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Podusage) ProtoMessage() {} + +func (x *Podusage) ProtoReflect() protoreflect.Message { + mi := &file_noderpc_noderpc_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Podusage.ProtoReflect.Descriptor instead. +func (*Podusage) Descriptor() ([]byte, []int) { + return file_noderpc_noderpc_proto_rawDescGZIP(), []int{2} +} + +func (x *Podusage) GetPoduuid() string { + if x != nil { + return x.Poduuid + } + return "" +} + +func (x *Podusage) GetPodvgpuinfo() *SharedRegionT { + if x != nil { + return x.Podvgpuinfo + } + return nil +} + +// The request message containing the user's name. +type GetNodeVGPURequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Ctruuid string `protobuf:"bytes,1,opt,name=ctruuid,proto3" json:"ctruuid,omitempty"` +} + +func (x *GetNodeVGPURequest) Reset() { + *x = GetNodeVGPURequest{} + if protoimpl.UnsafeEnabled { + mi := &file_noderpc_noderpc_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetNodeVGPURequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetNodeVGPURequest) ProtoMessage() {} + +func (x *GetNodeVGPURequest) ProtoReflect() protoreflect.Message { + mi := &file_noderpc_noderpc_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetNodeVGPURequest.ProtoReflect.Descriptor instead. +func (*GetNodeVGPURequest) Descriptor() ([]byte, []int) { + return file_noderpc_noderpc_proto_rawDescGZIP(), []int{3} +} + +func (x *GetNodeVGPURequest) GetCtruuid() string { + if x != nil { + return x.Ctruuid + } + return "" +} + +// The response message containing the greetings +type GetNodeVGPUReply struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Nodeid string `protobuf:"bytes,1,opt,name=nodeid,proto3" json:"nodeid,omitempty"` + Nodevgpuinfo []*Podusage `protobuf:"bytes,2,rep,name=nodevgpuinfo,proto3" json:"nodevgpuinfo,omitempty"` +} + +func (x *GetNodeVGPUReply) Reset() { + *x = GetNodeVGPUReply{} + if protoimpl.UnsafeEnabled { + mi := &file_noderpc_noderpc_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetNodeVGPUReply) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetNodeVGPUReply) ProtoMessage() {} + +func (x *GetNodeVGPUReply) ProtoReflect() protoreflect.Message { + mi := &file_noderpc_noderpc_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetNodeVGPUReply.ProtoReflect.Descriptor instead. +func (*GetNodeVGPUReply) Descriptor() ([]byte, []int) { + return file_noderpc_noderpc_proto_rawDescGZIP(), []int{4} +} + +func (x *GetNodeVGPUReply) GetNodeid() string { + if x != nil { + return x.Nodeid + } + return "" +} + +func (x *GetNodeVGPUReply) GetNodevgpuinfo() []*Podusage { + if x != nil { + return x.Nodevgpuinfo + } + return nil +} + +var File_noderpc_noderpc_proto protoreflect.FileDescriptor + +var file_noderpc_noderpc_proto_rawDesc = []byte{ + 0x0a, 0x15, 0x6e, 0x6f, 0x64, 0x65, 0x72, 0x70, 0x63, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x72, 0x70, + 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x09, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x72, + 0x70, 0x63, 0x22, 0x4f, 0x0a, 0x0f, 0x73, 0x68, 0x72, 0x72, 0x65, 0x67, 0x50, 0x72, 0x6f, 0x63, + 0x53, 0x6c, 0x6f, 0x74, 0x54, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x03, 0x70, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x64, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x04, 0x52, 0x04, 0x75, 0x73, 0x65, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x22, 0xca, 0x01, 0x0a, 0x0d, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x52, 0x65, + 0x67, 0x69, 0x6f, 0x6e, 0x54, 0x12, 0x28, 0x0a, 0x0f, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, + 0x69, 0x7a, 0x65, 0x64, 0x46, 0x6c, 0x61, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, + 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x46, 0x6c, 0x61, 0x67, 0x12, + 0x1a, 0x0a, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x50, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x50, 0x69, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x73, + 0x65, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x73, 0x65, 0x6d, 0x12, 0x14, 0x0a, + 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x04, 0x20, 0x03, 0x28, 0x04, 0x52, 0x05, 0x6c, 0x69, + 0x6d, 0x69, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x6d, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, + 0x05, 0x20, 0x03, 0x28, 0x04, 0x52, 0x07, 0x73, 0x6d, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x30, + 0x0a, 0x05, 0x70, 0x72, 0x6f, 0x63, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, + 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x73, 0x68, 0x72, 0x72, 0x65, 0x67, + 0x50, 0x72, 0x6f, 0x63, 0x53, 0x6c, 0x6f, 0x74, 0x54, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x63, 0x73, + 0x22, 0x60, 0x0a, 0x08, 0x70, 0x6f, 0x64, 0x75, 0x73, 0x61, 0x67, 0x65, 0x12, 0x18, 0x0a, 0x07, + 0x70, 0x6f, 0x64, 0x75, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, + 0x6f, 0x64, 0x75, 0x75, 0x69, 0x64, 0x12, 0x3a, 0x0a, 0x0b, 0x70, 0x6f, 0x64, 0x76, 0x67, 0x70, + 0x75, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x52, 0x65, + 0x67, 0x69, 0x6f, 0x6e, 0x54, 0x52, 0x0b, 0x70, 0x6f, 0x64, 0x76, 0x67, 0x70, 0x75, 0x69, 0x6e, + 0x66, 0x6f, 0x22, 0x2e, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x47, 0x50, + 0x55, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x74, 0x72, 0x75, + 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x74, 0x72, 0x75, 0x75, + 0x69, 0x64, 0x22, 0x63, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x47, 0x50, + 0x55, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x69, 0x64, 0x12, 0x37, + 0x0a, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x76, 0x67, 0x70, 0x75, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x72, 0x70, 0x63, + 0x2e, 0x70, 0x6f, 0x64, 0x75, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x76, + 0x67, 0x70, 0x75, 0x69, 0x6e, 0x66, 0x6f, 0x32, 0x5b, 0x0a, 0x0c, 0x4e, 0x6f, 0x64, 0x65, 0x56, + 0x47, 0x50, 0x55, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x4b, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x4e, 0x6f, + 0x64, 0x65, 0x56, 0x47, 0x50, 0x55, 0x12, 0x1d, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x72, + 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x47, 0x50, 0x55, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x72, 0x70, + 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x47, 0x50, 0x55, 0x52, 0x65, 0x70, + 0x6c, 0x79, 0x22, 0x00, 0x42, 0x4b, 0x0a, 0x1b, 0x69, 0x6f, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, + 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x2e, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, + 0x72, 0x6c, 0x64, 0x42, 0x0f, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x19, 0x67, 0x69, 0x74, 0x6c, 0x61, 0x62, 0x2e, 0x34, + 0x70, 0x64, 0x2e, 0x69, 0x6f, 0x2f, 0x76, 0x47, 0x50, 0x55, 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, + 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_noderpc_noderpc_proto_rawDescOnce sync.Once + file_noderpc_noderpc_proto_rawDescData = file_noderpc_noderpc_proto_rawDesc +) + +func file_noderpc_noderpc_proto_rawDescGZIP() []byte { + file_noderpc_noderpc_proto_rawDescOnce.Do(func() { + file_noderpc_noderpc_proto_rawDescData = protoimpl.X.CompressGZIP(file_noderpc_noderpc_proto_rawDescData) + }) + return file_noderpc_noderpc_proto_rawDescData +} + +var file_noderpc_noderpc_proto_msgTypes = make([]protoimpl.MessageInfo, 5) +var file_noderpc_noderpc_proto_goTypes = []interface{}{ + (*ShrregProcSlotT)(nil), // 0: pluginrpc.shrregProcSlotT + (*SharedRegionT)(nil), // 1: pluginrpc.sharedRegionT + (*Podusage)(nil), // 2: pluginrpc.podusage + (*GetNodeVGPURequest)(nil), // 3: pluginrpc.GetNodeVGPURequest + (*GetNodeVGPUReply)(nil), // 4: pluginrpc.GetNodeVGPUReply +} +var file_noderpc_noderpc_proto_depIdxs = []int32{ + 0, // 0: pluginrpc.sharedRegionT.procs:type_name -> pluginrpc.shrregProcSlotT + 1, // 1: pluginrpc.podusage.podvgpuinfo:type_name -> pluginrpc.sharedRegionT + 2, // 2: pluginrpc.GetNodeVGPUReply.nodevgpuinfo:type_name -> pluginrpc.podusage + 3, // 3: pluginrpc.NodeVGPUInfo.GetNodeVGPU:input_type -> pluginrpc.GetNodeVGPURequest + 4, // 4: pluginrpc.NodeVGPUInfo.GetNodeVGPU:output_type -> pluginrpc.GetNodeVGPUReply + 4, // [4:5] is the sub-list for method output_type + 3, // [3:4] is the sub-list for method input_type + 3, // [3:3] is the sub-list for extension type_name + 3, // [3:3] is the sub-list for extension extendee + 0, // [0:3] is the sub-list for field type_name +} + +func init() { file_noderpc_noderpc_proto_init() } +func file_noderpc_noderpc_proto_init() { + if File_noderpc_noderpc_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_noderpc_noderpc_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ShrregProcSlotT); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_noderpc_noderpc_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SharedRegionT); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_noderpc_noderpc_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Podusage); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_noderpc_noderpc_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetNodeVGPURequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_noderpc_noderpc_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetNodeVGPUReply); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_noderpc_noderpc_proto_rawDesc, + NumEnums: 0, + NumMessages: 5, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_noderpc_noderpc_proto_goTypes, + DependencyIndexes: file_noderpc_noderpc_proto_depIdxs, + MessageInfos: file_noderpc_noderpc_proto_msgTypes, + }.Build() + File_noderpc_noderpc_proto = out.File + file_noderpc_noderpc_proto_rawDesc = nil + file_noderpc_noderpc_proto_goTypes = nil + file_noderpc_noderpc_proto_depIdxs = nil +} diff --git a/cmd/vGPUmonitor/noderpc/noderpc.proto b/cmd/vGPUmonitor/noderpc/noderpc.proto new file mode 100644 index 0000000..611c3ec --- /dev/null +++ b/cmd/vGPUmonitor/noderpc/noderpc.proto @@ -0,0 +1,61 @@ +// Copyright 2015 gRPC authors. +// +// 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. + +syntax = "proto3"; + +option go_package = "gitlab.4pd.io/vGPUmonitor"; +option java_multiple_files = true; +option java_package = "io.grpc.examples.helloworld"; +option java_outer_classname = "HelloWorldProto"; + +package pluginrpc; + +// The greeting service definition. +service NodeVGPUInfo { + // Sends a greeting + rpc GetNodeVGPU (GetNodeVGPURequest) returns (GetNodeVGPUReply) {} +} + +// The sharedProcs contains the sharedRegion +message shrregProcSlotT { + int32 pid = 1; + repeated uint64 used = 2; + int32 status = 3; +} + +// The sharedRegionT struct is the main struct for monitoring vgpu +message sharedRegionT { + int32 initializedFlag = 1; + uint32 ownerPid = 2; + uint32 sem = 3; + repeated uint64 limit = 4; + repeated uint64 sm_limit = 5; + repeated shrregProcSlotT procs = 6; +} + +message podusage { + string poduuid = 1; + sharedRegionT podvgpuinfo = 2; +} + +// The request message containing the user's name. +message GetNodeVGPURequest { + string ctruuid = 1; +} + +// The response message containing the greetings +message GetNodeVGPUReply { + string nodeid = 1; + repeated podusage nodevgpuinfo = 2; +} diff --git a/cmd/vGPUmonitor/noderpc/noderpc_grpc.pb.go b/cmd/vGPUmonitor/noderpc/noderpc_grpc.pb.go new file mode 100644 index 0000000..346ed4c --- /dev/null +++ b/cmd/vGPUmonitor/noderpc/noderpc_grpc.pb.go @@ -0,0 +1,103 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. + +package vGPUmonitor + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +// NodeVGPUInfoClient is the client API for NodeVGPUInfo service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type NodeVGPUInfoClient interface { + // Sends a greeting + GetNodeVGPU(ctx context.Context, in *GetNodeVGPURequest, opts ...grpc.CallOption) (*GetNodeVGPUReply, error) +} + +type nodeVGPUInfoClient struct { + cc grpc.ClientConnInterface +} + +func NewNodeVGPUInfoClient(cc grpc.ClientConnInterface) NodeVGPUInfoClient { + return &nodeVGPUInfoClient{cc} +} + +func (c *nodeVGPUInfoClient) GetNodeVGPU(ctx context.Context, in *GetNodeVGPURequest, opts ...grpc.CallOption) (*GetNodeVGPUReply, error) { + out := new(GetNodeVGPUReply) + err := c.cc.Invoke(ctx, "/pluginrpc.NodeVGPUInfo/GetNodeVGPU", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// NodeVGPUInfoServer is the server API for NodeVGPUInfo service. +// All implementations must embed UnimplementedNodeVGPUInfoServer +// for forward compatibility +type NodeVGPUInfoServer interface { + // Sends a greeting + GetNodeVGPU(context.Context, *GetNodeVGPURequest) (*GetNodeVGPUReply, error) + mustEmbedUnimplementedNodeVGPUInfoServer() +} + +// UnimplementedNodeVGPUInfoServer must be embedded to have forward compatible implementations. +type UnimplementedNodeVGPUInfoServer struct { +} + +func (UnimplementedNodeVGPUInfoServer) GetNodeVGPU(context.Context, *GetNodeVGPURequest) (*GetNodeVGPUReply, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetNodeVGPU not implemented") +} +func (UnimplementedNodeVGPUInfoServer) mustEmbedUnimplementedNodeVGPUInfoServer() {} + +// UnsafeNodeVGPUInfoServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to NodeVGPUInfoServer will +// result in compilation errors. +type UnsafeNodeVGPUInfoServer interface { + mustEmbedUnimplementedNodeVGPUInfoServer() +} + +func RegisterNodeVGPUInfoServer(s grpc.ServiceRegistrar, srv NodeVGPUInfoServer) { + s.RegisterService(&NodeVGPUInfo_ServiceDesc, srv) +} + +func _NodeVGPUInfo_GetNodeVGPU_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetNodeVGPURequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(NodeVGPUInfoServer).GetNodeVGPU(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pluginrpc.NodeVGPUInfo/GetNodeVGPU", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(NodeVGPUInfoServer).GetNodeVGPU(ctx, req.(*GetNodeVGPURequest)) + } + return interceptor(ctx, in, info, handler) +} + +// NodeVGPUInfo_ServiceDesc is the grpc.ServiceDesc for NodeVGPUInfo service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var NodeVGPUInfo_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "pluginrpc.NodeVGPUInfo", + HandlerType: (*NodeVGPUInfoServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GetNodeVGPU", + Handler: _NodeVGPUInfo_GetNodeVGPU_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "noderpc/noderpc.proto", +} diff --git a/cmd/vGPUmonitor/pathmonitor.go b/cmd/vGPUmonitor/pathmonitor.go new file mode 100644 index 0000000..f319b74 --- /dev/null +++ b/cmd/vGPUmonitor/pathmonitor.go @@ -0,0 +1,176 @@ +/* +Copyright 2024 The HAMi Authors. + +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 main + +import ( + "context" + "errors" + "fmt" + "net" + "os" + "path/filepath" + "strings" + "sync" + "time" + + "google.golang.org/grpc" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/klog/v2" + + vGPUmonitor "volcano.sh/k8s-device-plugin/cmd/vGPUmonitor/noderpc" +) + +type podusage struct { + idstr string + sr *sharedRegionT +} + +var ( + containerPath string + nodeName string + lock sync.Mutex +) + +func init() { + hookPath, ok := os.LookupEnv("HOOK_PATH") + if ok { + containerPath = filepath.Join(hookPath, "containers") + } + nodeName = os.Getenv("NODE_NAME") +} + +func checkfiles(fpath string) (*sharedRegionT, error) { + klog.Infof("Checking path %s", fpath) + files, err := os.ReadDir(fpath) + if err != nil { + return nil, err + } + if len(files) > 2 { + return nil, errors.New("cache num not matched") + } + if len(files) == 0 { + return nil, nil + } + for _, val := range files { + if strings.Contains(val.Name(), "libvgpu.so") { + continue + } + if !strings.Contains(val.Name(), ".cache") { + continue + } + cachefile := fpath + "/" + val.Name() + nc := nvidiaCollector{ + cudevshrPath: cachefile, + at: nil, + } + sr, err := getvGPUMemoryInfo(&nc) + if err != nil { + klog.Errorf("getvGPUMemoryInfo failed: %v", err) + } else { + klog.Infof("getvGPUMemoryInfo success with utilizationSwitch=%d, recentKernel=%d, priority=%d", sr.utilizationSwitch, sr.recentKernel, sr.priority) + return sr, nil + } + } + return nil, nil +} + +func isVaildPod(name string, pods *corev1.PodList) bool { + for _, val := range pods.Items { + if strings.Contains(name, string(val.UID)) { + return true + } + } + return false +} + +func monitorPath(podmap map[string]podusage) error { + lock.Lock() + defer lock.Unlock() + files, err := os.ReadDir(containerPath) + if err != nil { + return err + } + pods, err := clientset.CoreV1().Pods("").List(context.Background(), metav1.ListOptions{ + FieldSelector: fmt.Sprintf("spec.nodeName=%s", nodeName), + }) + if err != nil { + klog.Errorf("Failed to get pods on node %s, error: %v", nodeName, err) + return nil + } + klog.Infof("Found %d pods on node %s", len(pods.Items), nodeName) + + for _, containerFile := range files { + dirname := containerPath + "/" + containerFile.Name() + if info, err1 := os.Stat(dirname); err1 != nil || !isVaildPod(info.Name(), pods) { + if info.ModTime().Add(time.Second * 300).Before(time.Now()) { + klog.Infof("Removing dirname %s in in monitorPath", dirname) + //syscall.Munmap(unsafe.Pointer(podmap[dirname].sr)) + delete(podmap, dirname) + err2 := os.RemoveAll(dirname) + if err2 != nil { + klog.Errorf("Failed to remove dirname: %s , error: %v", dirname, err) + return err2 + } + } + } else { + _, ok := podmap[dirname] + if !ok { + klog.Infof("Adding ctr dirname %s in monitorPath", dirname) + sharedRegion, err2 := checkfiles(dirname) + if err2 != nil { + klog.Errorf("Failed to checkfiles dirname: %s , error: %v", dirname, err) + return err2 + } + if sharedRegion == nil { + klog.Infof("nil shared region for dirname %s in monitorPath", dirname) + continue + } + + klog.Infof("Shared region after checking files: %v", *sharedRegion) + podmap[dirname] = podusage{ + idstr: containerFile.Name(), + sr: sharedRegion, + } + } + } + } + + klog.Infof("Monitored path map: %v", podmap) + return nil +} + +type server struct { + vGPUmonitor.UnimplementedNodeVGPUInfoServer +} + +func serveInfo(ch chan error) { + s := grpc.NewServer() + lis, err := net.Listen("tcp", ":9395") + if err != nil { + ch <- fmt.Errorf("failed to listen: %v", err) + // return respect the error, so the goroutine can end + return + } + vGPUmonitor.RegisterNodeVGPUInfoServer(s, &server{}) + klog.Infof("server listening at %v", lis.Addr()) + if err = s.Serve(lis); err != nil { + ch <- fmt.Errorf("failed to serve: %v", err) + // return respect the error, so the goroutine can end + return + } +} diff --git a/cmd/vGPUmonitor/pathmonitor_test.go b/cmd/vGPUmonitor/pathmonitor_test.go new file mode 100644 index 0000000..0f156da --- /dev/null +++ b/cmd/vGPUmonitor/pathmonitor_test.go @@ -0,0 +1,61 @@ +/* +Copyright 2024 The HAMi Authors. + +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 main + +import ( + "testing" + + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +func TestIsVaildPod(t *testing.T) { + pods := &corev1.PodList{ + Items: []corev1.Pod{ + { + ObjectMeta: metav1.ObjectMeta{ + UID: "123", + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + UID: "456", + }, + }, + }, + } + + cases := []struct { + name string + expected bool + }{ + { + name: "123", + expected: true, + }, + { + name: "789", + expected: false, + }, + } + + for _, c := range cases { + if got := isVaildPod(c.name, pods); got != c.expected { + t.Errorf("isVaildPod(%q) == %v, want %v", c.name, got, c.expected) + } + } +} diff --git a/cmd/vGPUmonitor/testcollector/main.go b/cmd/vGPUmonitor/testcollector/main.go new file mode 100644 index 0000000..bf13427 --- /dev/null +++ b/cmd/vGPUmonitor/testcollector/main.go @@ -0,0 +1,145 @@ +/* +Copyright 2024 The HAMi Authors. + +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 main + +import ( + "log" + "net/http" + + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/promhttp" +) + +// ClusterManager is an example for a system that might have been built without +// Prometheus in mind. It models a central manager of jobs running in a +// cluster. Thus, we implement a custom Collector called +// ClusterManagerCollector, which collects information from a ClusterManager +// using its provided methods and turns them into Prometheus Metrics for +// collection. +// +// An additional challenge is that multiple instances of the ClusterManager are +// run within the same binary, each in charge of a different zone. We need to +// make use of wrapping Registerers to be able to register each +// ClusterManagerCollector instance with Prometheus. +type ClusterManager struct { + Zone string + // Contains many more fields not listed in this example. +} + +// ReallyExpensiveAssessmentOfTheSystemState is a mock for the data gathering a +// real cluster manager would have to do. Since it may actually be really +// expensive, it must only be called once per collection. This implementation, +// obviously, only returns some made-up data. +func (c *ClusterManager) ReallyExpensiveAssessmentOfTheSystemState() ( + oomCountByHost map[string]int, ramUsageByHost map[string]float64, +) { + // Just example fake data. + oomCountByHost = map[string]int{ + "foo.example.org": 42, + "bar.example.org": 2001, + } + ramUsageByHost = map[string]float64{ + "foo.example.org": 6.023e23, + "bar.example.org": 3.14, + } + return +} + +// ClusterManagerCollector implements the Collector interface. +type ClusterManagerCollector struct { + ClusterManager *ClusterManager +} + +// Descriptors used by the ClusterManagerCollector below. +var ( + oomCountDesc = prometheus.NewDesc( + "clustermanager_oom_crashes_total", + "Number of OOM crashes.", + []string{"host"}, nil, + ) + ramUsageDesc = prometheus.NewDesc( + "clustermanager_ram_usage_bytes", + "RAM usage as reported to the cluster manager.", + []string{"host"}, nil, + ) +) + +// Describe is implemented with DescribeByCollect. That's possible because the +// Collect method will always return the same two metrics with the same two +// descriptors. +func (cc ClusterManagerCollector) Describe(ch chan<- *prometheus.Desc) { + prometheus.DescribeByCollect(cc, ch) +} + +// Collect first triggers the ReallyExpensiveAssessmentOfTheSystemState. Then it +// creates constant metrics for each host on the fly based on the returned data. +// +// Note that Collect could be called concurrently, so we depend on +// ReallyExpensiveAssessmentOfTheSystemState to be concurrency-safe. +func (cc ClusterManagerCollector) Collect(ch chan<- prometheus.Metric) { + oomCountByHost, ramUsageByHost := cc.ClusterManager.ReallyExpensiveAssessmentOfTheSystemState() + for host, oomCount := range oomCountByHost { + ch <- prometheus.MustNewConstMetric( + oomCountDesc, + prometheus.CounterValue, + float64(oomCount), + host, + ) + } + for host, ramUsage := range ramUsageByHost { + ch <- prometheus.MustNewConstMetric( + ramUsageDesc, + prometheus.GaugeValue, + ramUsage, + host, + ) + } +} + +// NewClusterManager first creates a Prometheus-ignorant ClusterManager +// instance. Then, it creates a ClusterManagerCollector for the just created +// ClusterManager. Finally, it registers the ClusterManagerCollector with a +// wrapping Registerer that adds the zone as a label. In this way, the metrics +// collected by different ClusterManagerCollectors do not collide. +func NewClusterManager(zone string, reg prometheus.Registerer) *ClusterManager { + c := &ClusterManager{ + Zone: zone, + } + cc := ClusterManagerCollector{ClusterManager: c} + prometheus.WrapRegistererWith(prometheus.Labels{"zone": zone}, reg).MustRegister(cc) + return c +} + +func main() { + // Since we are dealing with custom Collector implementations, it might + // be a good idea to try it out with a pedantic registry. + reg := prometheus.NewPedanticRegistry() + + // Construct cluster managers. In real code, we would assign them to + // variables to then do something with them. + NewClusterManager("db", reg) + NewClusterManager("ca", reg) + + // Add the standard process and Go metrics to the custom registry. + reg.MustRegister( + prometheus.NewProcessCollector(prometheus.ProcessCollectorOpts{}), + prometheus.NewGoCollector(), + ) + + http.Handle("/metrics", promhttp.HandlerFor(reg, promhttp.HandlerOpts{})) + log.Fatal(http.ListenAndServe(":8080", nil)) +} diff --git a/cmd/vGPUmonitor/validation.go b/cmd/vGPUmonitor/validation.go new file mode 100644 index 0000000..fbba208 --- /dev/null +++ b/cmd/vGPUmonitor/validation.go @@ -0,0 +1,37 @@ +/* +Copyright 2024 The HAMi Authors. + +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 main + +import ( + "fmt" + "os" +) + +var requiredEnvVars = map[string]bool{ + "HOOK_PATH": true, + "OTHER_ENV_VAR": false, +} + +func ValidateEnvVars() error { + for envVar, required := range requiredEnvVars { + _, exists := os.LookupEnv(envVar) + if required && !exists { + return fmt.Errorf("required environment variable %s not set", envVar) + } + } + return nil +} diff --git a/docker/amd64/Dockerfile.vgpu-monitor-ubuntu20.04 b/docker/amd64/Dockerfile.vgpu-monitor-ubuntu20.04 new file mode 100644 index 0000000..c5bd2e8 --- /dev/null +++ b/docker/amd64/Dockerfile.vgpu-monitor-ubuntu20.04 @@ -0,0 +1,20 @@ +FROM ubuntu:20.04 AS builder +RUN apt-get update && apt-get install -y --no-install-recommends \ + g++ \ + ca-certificates \ + wget && \ + rm -rf /var/lib/apt/lists/* +ENV GOLANG_VERSION 1.19.3 +ENV GOPATH /go +ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH +WORKDIR /go/src/volcano.sh/devices +COPY . . +RUN wget -nv https://storage.googleapis.com/golang/go$GOLANG_VERSION.linux-amd64.tar.gz +RUN tar -C /usr/local -xzf go$GOLANG_VERSION.linux-amd64.tar.gz +RUN go env -w GO111MODULE=on +RUN go env -w GOPROXY=https://goproxy.cn,direct +RUN export CGO_LDFLAGS_ALLOW='-Wl,--unresolved-symbols=ignore-in-object-files' && \ + go build -ldflags="-s -w" -o vGPUmonitor ./cmd/vGPUmonitor + +FROM debian:stretch-slim +COPY --from=builder /go/src/volcano.sh/devices/vGPUmonitor /usr/bin/vGPUmonitor diff --git a/go.mod b/go.mod index 007353b..129e741 100644 --- a/go.mod +++ b/go.mod @@ -2,6 +2,31 @@ module volcano.sh/k8s-device-plugin go 1.14 +require ( + github.com/NVIDIA/go-gpuallocator v0.2.3 + github.com/NVIDIA/go-nvml v0.12.4-0 + github.com/NVIDIA/gpu-monitoring-tools v0.0.0-20201109160820-d08ea3cdcce4 + github.com/fsnotify/fsnotify v1.4.9 + github.com/prometheus/client_golang v1.0.0 + github.com/prometheus/common v0.4.1 + github.com/spf13/cobra v0.0.5 + github.com/spf13/viper v1.3.2 + github.com/stretchr/testify v1.9.0 + github.com/urfave/cli/v2 v2.4.0 + golang.org/x/exp v0.0.0-20190312203227-4b39c73a6495 + golang.org/x/net v0.0.0-20200421231249-e086a090c8fd + google.golang.org/grpc v1.32.0 + google.golang.org/protobuf v1.34.2 + k8s.io/api v0.18.2 + k8s.io/apimachinery v0.18.2 + k8s.io/client-go v0.18.2 + k8s.io/klog v1.0.0 + k8s.io/klog/v2 v2.80.1 + k8s.io/kubelet v0.0.0 + k8s.io/kubernetes v1.18.2 + sigs.k8s.io/yaml v1.2.0 +) + replace ( k8s.io/api => k8s.io/api v0.18.2 k8s.io/apiextensions-apiserver => k8s.io/apiextensions-apiserver v0.18.2 @@ -26,25 +51,3 @@ replace ( k8s.io/metrics => k8s.io/metrics v0.18.2 k8s.io/sample-apiserver => k8s.io/sample-apiserver v0.18.2 ) - -require ( - github.com/NVIDIA/go-gpuallocator v0.2.3 - github.com/NVIDIA/gpu-monitoring-tools v0.0.0-20201109160820-d08ea3cdcce4 - github.com/fsnotify/fsnotify v1.4.9 - github.com/mitchellh/gox v1.0.1 // indirect - github.com/prometheus/common v0.4.1 - github.com/spf13/cobra v0.0.5 - github.com/spf13/viper v1.3.2 - github.com/stretchr/testify v1.5.1 - github.com/urfave/cli/v2 v2.4.0 - golang.org/x/net v0.0.0-20200421231249-e086a090c8fd - google.golang.org/grpc v1.29.0 - k8s.io/api v0.18.2 - k8s.io/apimachinery v0.18.2 - k8s.io/client-go v0.18.2 - k8s.io/klog v1.0.0 - k8s.io/klog/v2 v2.80.1 - k8s.io/kubelet v0.0.0 - k8s.io/kubernetes v1.18.2 - sigs.k8s.io/yaml v1.2.0 -) diff --git a/go.sum b/go.sum index 8ccac0b..f5eacb1 100644 --- a/go.sum +++ b/go.sum @@ -23,6 +23,8 @@ github.com/Microsoft/go-winio v0.4.14/go.mod h1:qXqCSQ3Xa7+6tgxaGTIe4Kpcdsi+P8jB github.com/Microsoft/hcsshim v0.0.0-20190417211021-672e52e9209d/go.mod h1:Op3hHsoHPAvb6lceZHDtd9OkTew38wNoXnJs8iY7rUg= github.com/NVIDIA/go-gpuallocator v0.2.3 h1:YTXxNpHo71u16DPBWSsHpxV/Eac76ElF5B/rDOM9zqc= github.com/NVIDIA/go-gpuallocator v0.2.3/go.mod h1:cNlWZtJeN15qXGoOzZnOA9yY3CiJrUtUsfGJHFefiDA= +github.com/NVIDIA/go-nvml v0.12.4-0 h1:4tkbB3pT1O77JGr0gQ6uD8FrsUPqP1A/EOEm2wI1TUg= +github.com/NVIDIA/go-nvml v0.12.4-0/go.mod h1:8Llmj+1Rr+9VGGwZuRer5N/aCjxGuR5nPb/9ebBiIEQ= github.com/NVIDIA/gpu-monitoring-tools v0.0.0-20201109160820-d08ea3cdcce4 h1:6KSetbMgb2MieLm34BNJKiEuiP5Tj9Tr94wTipnlYDA= github.com/NVIDIA/gpu-monitoring-tools v0.0.0-20201109160820-d08ea3cdcce4/go.mod h1:l0Cq257MSJMvg9URCXUjc8pgKY2SK1oSvIx6qG0bzzc= github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb06e3pkSAbeQ52E9H9iFoQsEEwGN64994WTCIhntQ= @@ -55,6 +57,7 @@ github.com/bazelbuild/buildtools v0.0.0-20190731111112-f720930ceb60/go.mod h1:5J github.com/bazelbuild/buildtools v0.0.0-20190917191645-69366ca98f89/go.mod h1:5JP0TXzWDHXv8qvxRC4InIazwdyDseBDbzESUMKk1yU= github.com/bazelbuild/rules_go v0.0.0-20190719190356-6dae44dc5cab/go.mod h1:MC23Dc/wkXEyk3Wpq6lCqz0ZAYOZDw2DR5y3N1q2i7M= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= +github.com/beorn7/perks v1.0.0 h1:HWo1m869IqiPhD389kmkxeTalrjNbbJTC8LXupb+sl0= github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= github.com/bifurcation/mint v0.0.0-20180715133206-93c51c6ce115/go.mod h1:zVt7zX3K/aDCk9Tj+VM7YymsX66ERvzCJzw8rFCX2JU= @@ -211,6 +214,7 @@ github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls= github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903 h1:LbsanbbD6LieFkXbj9YNNBupiGHJgFeLpO0j0Fza1h8= github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/mock v1.0.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= @@ -220,8 +224,9 @@ github.com/golang/protobuf v0.0.0-20161109072736-4bd1920723d7/go.mod h1:6lQm79b+ github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.3 h1:gyjaxf+svBWX08ZjK86iN9geUJF0H6gp2IRKX6Nf6/I= github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.5.0 h1:LUVKkCeviFUMKqHa4tXIIij/lbhnMbP7Fn5wKdKkRh4= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= github.com/golangci/check v0.0.0-20180506172741-cfe4005ccda2/go.mod h1:k9Qvh+8juN+UKMCS/3jFtGICgW8O96FVaZsaxdzDkR4= github.com/golangci/dupl v0.0.0-20180902072040-3e9179ac440a/go.mod h1:ryS0uhF+x9jgbj/N71xsEqODy9BN81/GonCZiOzirOk= github.com/golangci/errcheck v0.0.0-20181223084120-ef45e06d44b6/go.mod h1:DbHgvLiFKX1Sh2T1w8Q/h4NAI8MHIpzCdnBUDTXU3I0= @@ -246,8 +251,10 @@ github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Z github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/cadvisor v0.35.0/go.mod h1:1nql6U13uTHaLYB8rLS5x9IJc2qT6Xd/Tr1sTX6NE48= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= -github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY= github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ= github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= @@ -257,8 +264,9 @@ github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXi github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY= github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gnostic v0.0.0-20170729233727-0c5108395e2d/go.mod h1:sJBsCZ4ayReDTBIg8b9dl28c5xFWyhBTVRp3pOg5EKY= github.com/googleapis/gnostic v0.1.0 h1:rVsPeBmXbYv4If/cumu1AzZPwV58q433hvONV1UEZoI= @@ -281,6 +289,7 @@ github.com/hashicorp/go-version v1.0.0 h1:21MVWPKDphxa7ineQQTrCU5brh7OuVVAzGOCnn github.com/hashicorp/go-version v1.0.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= github.com/hashicorp/golang-lru v0.0.0-20180201235237-0fb14efe8c47/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.1 h1:0hERBMJE1eitiLkihrMvRVBYAkpHzc/J3QdDN+dAcgU= github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/hcl v0.0.0-20180404174102-ef8a98b0bbce/go.mod h1:oZtUIOe8dh44I2q6ScRibXws4Ajl+d+nod3AaR9vL5w= github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= @@ -352,6 +361,7 @@ github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2y github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-shellwords v1.0.5/go.mod h1:3xCvwCdWdlDJUrvuMn7Wuy9eWs4pE8vqg+NOMyg4B2o= github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw= +github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/mesos/mesos-go v0.0.9/go.mod h1:kPYCMQ9gsOXVAle1OsoY4I1+9kPu8GHkf88aV59fDr4= github.com/mholt/certmagic v0.6.2-0.20190624175158-6a42ef9fe8c2/go.mod h1:g4cOPxcjV0oFq3qwpjSA30LReKD8AoIfwAY9VvG35NY= @@ -418,14 +428,17 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN github.com/pquerna/cachecontrol v0.0.0-20171018203845-0dec1b30a021/go.mod h1:prYjPmNq4d1NPVmpShWobRqXY3q7Vp+80DqgxxUrUIA= github.com/pquerna/ffjson v0.0.0-20180717144149-af8b230fcd20/go.mod h1:YARuvh7BUWHNhzDq2OM5tzR2RiCcN2D7sapiKyCel/M= github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= +github.com/prometheus/client_golang v1.0.0 h1:vrDKnkGzuGvhNAL56c7DBz29ZL+KxnoR0x7enabFceM= github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo= github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M= github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/common v0.4.1 h1:K0MGApIoQvMw27RTdJkPbr3JZ7DNbtxQNyi5STVM6Kw= github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= +github.com/prometheus/procfs v0.0.2 h1:6LJUbpNm42llc4HRCuvApCSWB/WfhuNo9K98Q9sNGfs= github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= github.com/quasilyte/go-consistent v0.0.0-20190521200055-c6f3937de18c/go.mod h1:5STLWrekHfjyYwxBRVRXNOSewLJ3PWfDJd1VyTS21fI= github.com/quobyte/api v0.1.2/go.mod h1:jL7lIHrmqQ7yh05OJ+eEEdHr0u/kmT1Ff9iHd+4H6VI= @@ -487,11 +500,18 @@ github.com/storageos/go-api v0.0.0-20180912212459-343b3eff91fc/go.mod h1:ZrLn+e0 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= -github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/syndtr/gocapability v0.0.0-20180916011248-d98352740cb2/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww= github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA= github.com/thecodeteam/goscaleio v0.1.0/go.mod h1:68sdkZAsK8bvEwBlbQnlLS+xU+hvLYM/iQ8KXej1AwM= @@ -548,6 +568,7 @@ golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190312203227-4b39c73a6495 h1:I6A9Ag9FpEKOjcKrRNjQkPHawoXIhKyTGfvvjFAiiAk= golang.org/x/exp v0.0.0-20190312203227-4b39c73a6495/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= @@ -663,6 +684,8 @@ golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgw golang.org/x/tools v0.0.0-20190909030654-5b82db07426d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20190920225731-5eefd052ad72/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo= gonum.org/v1/gonum v0.0.0-20190331200053-3d26580ed485/go.mod h1:2ltnJ7xHfj0zHS40VVPYEAAMTa3ZGguvHGBSJeRWqE0= gonum.org/v1/gonum v0.6.2/go.mod h1:9mxDZsDKxgMAuccQkewq682L+0eCu4dCN2yonUJTCLU= @@ -688,8 +711,11 @@ google.golang.org/grpc v1.23.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyac google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.28.1/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= -google.golang.org/grpc v1.29.0 h1:2pJjwYOdkZ9HlN4sWRYBg9ttH5bCOlsueaM+b/oYjwo= -google.golang.org/grpc v1.29.0/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= +google.golang.org/grpc v1.32.0 h1:zWTV+LMdc3kaiJMSTOFz2UgSBgx8RNQoTGiZu3fR9S0= +google.golang.org/grpc v1.32.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= +google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U= gopkg.in/alecthomas/kingpin.v2 v2.2.6 h1:jMFz6MfLP0/4fUyZle81rXUoxOBFi19VUFKVDOQfozc= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= @@ -717,6 +743,9 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gotest.tools v2.1.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw= gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw= gotest.tools/gotestsum v0.3.5/go.mod h1:Mnf3e5FUzXbkCfynWBGOwLssY7gTQgCHObK9tMpAriY= diff --git a/volcano-vgpu-device-plugin.yml b/volcano-vgpu-device-plugin.yml index e37ebad..ccd3124 100644 --- a/volcano-vgpu-device-plugin.yml +++ b/volcano-vgpu-device-plugin.yml @@ -108,13 +108,70 @@ spec: mountPath: /usr/local/vgpu - name: hosttmp mountPath: /tmp + - image: docker.io/projecthami/volcano-vgpu-monitor:v1.9.3 + imagePullPolicy: Always + name: monitor + command: + - /bin/bash + - -c + - vGPUmonitor + env: + - name: NVIDIA_VISIBLE_DEVICES + value: "all" + - name: NVIDIA_MIG_MONITOR_DEVICES + value: "all" + - name: HOOK_PATH + value: "/tmp/vgpu" + - name: NODE_NAME + valueFrom: + fieldRef: + fieldPath: spec.nodeName + securityContext: + allowPrivilegeEscalation: false + capabilities: + drop: ["ALL"] + add: ["SYS_ADMIN"] + volumeMounts: + - name: dockers + mountPath: /run/docker + - name: containerds + mountPath: /run/containerd + - name: sysinfo + mountPath: /sysinfo + - name: hostvar + mountPath: /hostvar + - name: hosttmp + mountPath: /tmp volumes: - - name: device-plugin - hostPath: + - hostPath: path: /var/lib/kubelet/device-plugins - - name: lib - hostPath: + type: Directory + name: device-plugin + - hostPath: path: /usr/local/vgpu + type: DirectoryOrCreate + name: lib - name: hosttmp hostPath: path: /tmp + type: DirectoryOrCreate + - name: dockers + hostPath: + path: /run/docker + type: DirectoryOrCreate + - name: containerds + hostPath: + path: /run/containerd + type: DirectoryOrCreate + - name: usrbin + hostPath: + path: /usr/bin + type: Directory + - name: sysinfo + hostPath: + path: /sys + type: Directory + - name: hostvar + hostPath: + path: /var + type: Directory \ No newline at end of file From c569eef967f6fc347725ee5763818ed76267a626 Mon Sep 17 00:00:00 2001 From: zhitianli Date: Fri, 9 Aug 2024 15:37:41 +0800 Subject: [PATCH 2/3] remove useless noderpc in vGPUmonitor --- cmd/vGPUmonitor/cudevshr.go | 48 -- cmd/vGPUmonitor/feedback.go | 146 ------ cmd/vGPUmonitor/main.go | 2 - cmd/vGPUmonitor/metrics.go | 14 - cmd/vGPUmonitor/noderpc/noderpc.pb.go | 518 --------------------- cmd/vGPUmonitor/noderpc/noderpc.proto | 61 --- cmd/vGPUmonitor/noderpc/noderpc_grpc.pb.go | 103 ---- cmd/vGPUmonitor/pathmonitor.go | 25 - 8 files changed, 917 deletions(-) delete mode 100644 cmd/vGPUmonitor/noderpc/noderpc.pb.go delete mode 100644 cmd/vGPUmonitor/noderpc/noderpc.proto delete mode 100644 cmd/vGPUmonitor/noderpc/noderpc_grpc.pb.go diff --git a/cmd/vGPUmonitor/cudevshr.go b/cmd/vGPUmonitor/cudevshr.go index e859b31..11d2f5b 100644 --- a/cmd/vGPUmonitor/cudevshr.go +++ b/cmd/vGPUmonitor/cudevshr.go @@ -17,8 +17,6 @@ limitations under the License. package main import ( - "bytes" - "encoding/binary" "errors" "fmt" "os" @@ -28,8 +26,6 @@ import ( "golang.org/x/exp/mmap" ) -const maxDevices = 16 - type deviceMemory struct { contextSize uint64 moduleSize uint64 @@ -72,13 +68,6 @@ type sharedRegionT struct { priority int32 } -type SharedRegionInfoT struct { - pid int32 - fd int32 - initStatus int16 - sharedRegion sharedRegionT -} - type nvidiaCollector struct { // Exposed for testing cudevshrPath string @@ -86,43 +75,6 @@ type nvidiaCollector struct { cudaCache *sharedRegionT } -func setProcSlot(offset int64, at *mmap.ReaderAt) (shrregProcSlotT, error) { - temp := shrregProcSlotT{} - buff := make([]byte, 4) - at.ReadAt(buff, offset) - bytesbuffer := bytes.NewBuffer(buff) - binary.Read(bytesbuffer, binary.LittleEndian, &temp.pid) - var monitorused uint64 - //fmt.Println("pid==", temp.pid, "buff=", buff) - buff = make([]byte, 8) - for i := 0; i < maxDevices; i++ { - at.ReadAt(buff, offset+8+8*int64(i)) - bytesbuffer = bytes.NewBuffer(buff) - binary.Read(bytesbuffer, binary.LittleEndian, &temp.used[i]) - } - for i := 0; i < maxDevices; i++ { - at.ReadAt(buff, offset+8+8*16+8*int64(i)) - bytesbuffer = bytes.NewBuffer(buff) - binary.Read(bytesbuffer, binary.LittleEndian, &monitorused) - if monitorused > temp.used[i].total { - temp.used[i].total = monitorused - } - } - return temp, nil -} - -func getDeviceUsedMemory(idx int, sharedregion sharedRegionT) (uint64, error) { - var sum uint64 - sum = 0 - if idx < 0 || idx > 16 { - return 0, errors.New("out of device idx") - } - for _, val := range sharedregion.procs { - sum += val.used[idx].total - } - return sum, nil -} - func mmapcachefile(filename string, nc *nvidiaCollector) error { var m = &sharedRegionT{} f, err := os.OpenFile(filename, os.O_RDWR, 0666) diff --git a/cmd/vGPUmonitor/feedback.go b/cmd/vGPUmonitor/feedback.go index 56dda7d..9953c50 100644 --- a/cmd/vGPUmonitor/feedback.go +++ b/cmd/vGPUmonitor/feedback.go @@ -17,166 +17,20 @@ limitations under the License. package main import ( - "errors" - "fmt" - "os" - "sort" - "strconv" - "strings" - "sync" "time" "github.com/NVIDIA/go-nvml/pkg/nvml" - corev1 "k8s.io/api/core/v1" "k8s.io/klog/v2" ) -var cgroupDriver int - -type hostGPUPid struct { - hostGPUPid int - mtime uint64 -} - type UtilizationPerDevice []int -var mutex sync.Mutex var srPodList map[string]podusage func init() { srPodList = make(map[string]podusage) } -func setcGgroupDriver() int { - // 1 for cgroupfs 2 for systemd - kubeletconfig, err := os.ReadFile("/hostvar/lib/kubelet/config.yaml") - if err != nil { - return 0 - } - content := string(kubeletconfig) - pos := strings.LastIndex(content, "cgroupDriver:") - if pos < 0 { - return 0 - } - if strings.Contains(content, "systemd") { - return 2 - } - if strings.Contains(content, "cgroupfs") { - return 1 - } - return 0 -} - -func getUsedGPUPid() ([]uint, nvml.Return) { - tmp := []nvml.ProcessInfo{} - count, err := nvml.DeviceGetCount() - if err != nvml.SUCCESS { - return []uint{}, err - } - for i := 0; i < count; i++ { - device, err := nvml.DeviceGetHandleByIndex(i) - if err != nvml.SUCCESS { - return []uint{}, err - } - ids, err := device.GetComputeRunningProcesses() - if err != nvml.SUCCESS { - return []uint{}, err - } - tmp = append(tmp, ids...) - } - result := make([]uint, 0) - m := make(map[uint]bool) - for _, v := range tmp { - if _, ok := m[uint(v.Pid)]; !ok { - result = append(result, uint(v.Pid)) - m[uint(v.Pid)] = true - } - } - sort.Slice(tmp, func(i, j int) bool { return tmp[i].Pid > tmp[j].Pid }) - return result, nvml.SUCCESS -} - -func setHostPid(pod corev1.Pod, ctr corev1.ContainerStatus, sr *podusage) error { - var pids []string - mutex.Lock() - defer mutex.Unlock() - - if cgroupDriver == 0 { - cgroupDriver = setcGgroupDriver() - } - if cgroupDriver == 0 { - return errors.New("can not identify cgroup driver") - } - usedGPUArray, err := getUsedGPUPid() - if err != nvml.SUCCESS { - return errors.New("get usedGPUID failed, ret:" + nvml.ErrorString(err)) - } - if len(usedGPUArray) == 0 { - return nil - } - qos := strings.ToLower(string(pod.Status.QOSClass)) - var filename string - if cgroupDriver == 1 { - /* Cgroupfs */ - filename = fmt.Sprintf("/sysinfo/fs/cgroup/memory/kubepods/%s/pod%s/%s/tasks", qos, pod.UID, strings.TrimPrefix(ctr.ContainerID, "docker://")) - } - if cgroupDriver == 2 { - /* Systemd */ - cgroupuid := strings.ReplaceAll(string(pod.UID), "-", "_") - filename = fmt.Sprintf("/sysinfo/fs/cgroup/systemd/kubepods.slice/kubepods-%s.slice/kubepods-%s-pod%s.slice/docker-%s.scope/tasks", qos, qos, cgroupuid, strings.TrimPrefix(ctr.ContainerID, "docker://")) - } - fmt.Println("filename=", filename) - content, ferr := os.ReadFile(filename) - if ferr != nil { - return ferr - } - pids = strings.Split(string(content), "\n") - hostPidArray := []hostGPUPid{} - for _, val := range pids { - tmp, _ := strconv.Atoi(val) - if tmp != 0 { - var stat os.FileInfo - var err error - if stat, err = os.Lstat(fmt.Sprintf("/proc/%v", tmp)); err != nil { - return err - } - mtime := stat.ModTime().Unix() - hostPidArray = append(hostPidArray, hostGPUPid{ - hostGPUPid: tmp, - mtime: uint64(mtime), - }) - } - } - usedGPUHostArray := []hostGPUPid{} - for _, val := range usedGPUArray { - for _, hostpid := range hostPidArray { - if uint(hostpid.hostGPUPid) == val { - usedGPUHostArray = append(usedGPUHostArray, hostpid) - } - } - } - //fmt.Println("usedHostGPUArray=", usedGPUHostArray) - sort.Slice(usedGPUHostArray, func(i, j int) bool { return usedGPUHostArray[i].mtime > usedGPUHostArray[j].mtime }) - if sr == nil || sr.sr == nil { - return nil - } - for idx, val := range sr.sr.procs { - //fmt.Println("pid=", val.pid) - if val.pid == 0 { - break - } - if idx < len(usedGPUHostArray) { - if val.hostpid == 0 || val.hostpid != int32(usedGPUHostArray[idx].hostGPUPid) { - fmt.Println("Assign host pid to pid instead", usedGPUHostArray[idx].hostGPUPid, val.pid, val.hostpid) - sr.sr.procs[idx].hostpid = int32(usedGPUHostArray[idx].hostGPUPid) - fmt.Println("val=", val.hostpid, sr.sr.procs[idx].hostpid) - } - } - } - return nil - -} - func CheckBlocking(utSwitchOn map[string]UtilizationPerDevice, p int, pu podusage) bool { for _, devuuid := range pu.sr.uuids { _, ok := utSwitchOn[string(devuuid.uuid[:])] diff --git a/cmd/vGPUmonitor/main.go b/cmd/vGPUmonitor/main.go index dbac560..14ff97b 100644 --- a/cmd/vGPUmonitor/main.go +++ b/cmd/vGPUmonitor/main.go @@ -24,9 +24,7 @@ func main() { if err := ValidateEnvVars(); err != nil { klog.Fatalf("Failed to validate environment variables: %v", err) } - cgroupDriver = 0 errchannel := make(chan error) - go serveInfo(errchannel) go initMetrics() go watchAndFeedback() for { diff --git a/cmd/vGPUmonitor/metrics.go b/cmd/vGPUmonitor/metrics.go index 47d5aef..2ee882d 100644 --- a/cmd/vGPUmonitor/metrics.go +++ b/cmd/vGPUmonitor/metrics.go @@ -17,7 +17,6 @@ limitations under the License. package main import ( - "errors" "fmt" "log" "net/http" @@ -121,15 +120,6 @@ func (cc ClusterManagerCollector) Describe(ch chan<- *prometheus.Desc) { //prometheus.DescribeByCollect(cc, ch) } -func parseidstr(podusage string) (string, string, error) { - tmp := strings.Split(podusage, "_") - if len(tmp) > 1 { - return tmp[0], tmp[1], nil - } else { - return "", "", errors.New("parse error") - } -} - func gettotalusage(usage podusage, vidx int) (deviceMemory, error) { added := deviceMemory{ bufferSize: 0, @@ -148,10 +138,6 @@ func gettotalusage(usage podusage, vidx int) (deviceMemory, error) { return added, nil } -func getsrlist() map[string]podusage { - return srPodList -} - // Collect first triggers the ReallyExpensiveAssessmentOfTheSystemState. Then it // creates constant metrics for each host on the fly based on the returned data. // diff --git a/cmd/vGPUmonitor/noderpc/noderpc.pb.go b/cmd/vGPUmonitor/noderpc/noderpc.pb.go deleted file mode 100644 index 4c732b8..0000000 --- a/cmd/vGPUmonitor/noderpc/noderpc.pb.go +++ /dev/null @@ -1,518 +0,0 @@ -// Copyright 2015 gRPC authors. -// -// 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. - -// Code generated by protoc-gen-go. DO NOT EDIT. -// versions: -// protoc-gen-go v1.27.1 -// protoc v3.14.0 -// source: noderpc/noderpc.proto - -package vGPUmonitor - -import ( - protoreflect "google.golang.org/protobuf/reflect/protoreflect" - protoimpl "google.golang.org/protobuf/runtime/protoimpl" - reflect "reflect" - sync "sync" -) - -const ( - // Verify that this generated code is sufficiently up-to-date. - _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) - // Verify that runtime/protoimpl is sufficiently up-to-date. - _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) -) - -// The sharedProcs contains the sharedRegion -type ShrregProcSlotT struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Pid int32 `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"` - Used []uint64 `protobuf:"varint,2,rep,packed,name=used,proto3" json:"used,omitempty"` - Status int32 `protobuf:"varint,3,opt,name=status,proto3" json:"status,omitempty"` -} - -func (x *ShrregProcSlotT) Reset() { - *x = ShrregProcSlotT{} - if protoimpl.UnsafeEnabled { - mi := &file_noderpc_noderpc_proto_msgTypes[0] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *ShrregProcSlotT) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ShrregProcSlotT) ProtoMessage() {} - -func (x *ShrregProcSlotT) ProtoReflect() protoreflect.Message { - mi := &file_noderpc_noderpc_proto_msgTypes[0] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use ShrregProcSlotT.ProtoReflect.Descriptor instead. -func (*ShrregProcSlotT) Descriptor() ([]byte, []int) { - return file_noderpc_noderpc_proto_rawDescGZIP(), []int{0} -} - -func (x *ShrregProcSlotT) GetPid() int32 { - if x != nil { - return x.Pid - } - return 0 -} - -func (x *ShrregProcSlotT) GetUsed() []uint64 { - if x != nil { - return x.Used - } - return nil -} - -func (x *ShrregProcSlotT) GetStatus() int32 { - if x != nil { - return x.Status - } - return 0 -} - -// The sharedRegionT struct is the main struct for monitoring vgpu -type SharedRegionT struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - InitializedFlag int32 `protobuf:"varint,1,opt,name=initializedFlag,proto3" json:"initializedFlag,omitempty"` - OwnerPid uint32 `protobuf:"varint,2,opt,name=ownerPid,proto3" json:"ownerPid,omitempty"` - Sem uint32 `protobuf:"varint,3,opt,name=sem,proto3" json:"sem,omitempty"` - Limit []uint64 `protobuf:"varint,4,rep,packed,name=limit,proto3" json:"limit,omitempty"` - SmLimit []uint64 `protobuf:"varint,5,rep,packed,name=sm_limit,json=smLimit,proto3" json:"sm_limit,omitempty"` - Procs []*ShrregProcSlotT `protobuf:"bytes,6,rep,name=procs,proto3" json:"procs,omitempty"` -} - -func (x *SharedRegionT) Reset() { - *x = SharedRegionT{} - if protoimpl.UnsafeEnabled { - mi := &file_noderpc_noderpc_proto_msgTypes[1] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *SharedRegionT) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SharedRegionT) ProtoMessage() {} - -func (x *SharedRegionT) ProtoReflect() protoreflect.Message { - mi := &file_noderpc_noderpc_proto_msgTypes[1] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SharedRegionT.ProtoReflect.Descriptor instead. -func (*SharedRegionT) Descriptor() ([]byte, []int) { - return file_noderpc_noderpc_proto_rawDescGZIP(), []int{1} -} - -func (x *SharedRegionT) GetInitializedFlag() int32 { - if x != nil { - return x.InitializedFlag - } - return 0 -} - -func (x *SharedRegionT) GetOwnerPid() uint32 { - if x != nil { - return x.OwnerPid - } - return 0 -} - -func (x *SharedRegionT) GetSem() uint32 { - if x != nil { - return x.Sem - } - return 0 -} - -func (x *SharedRegionT) GetLimit() []uint64 { - if x != nil { - return x.Limit - } - return nil -} - -func (x *SharedRegionT) GetSmLimit() []uint64 { - if x != nil { - return x.SmLimit - } - return nil -} - -func (x *SharedRegionT) GetProcs() []*ShrregProcSlotT { - if x != nil { - return x.Procs - } - return nil -} - -type Podusage struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Poduuid string `protobuf:"bytes,1,opt,name=poduuid,proto3" json:"poduuid,omitempty"` - Podvgpuinfo *SharedRegionT `protobuf:"bytes,2,opt,name=podvgpuinfo,proto3" json:"podvgpuinfo,omitempty"` -} - -func (x *Podusage) Reset() { - *x = Podusage{} - if protoimpl.UnsafeEnabled { - mi := &file_noderpc_noderpc_proto_msgTypes[2] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Podusage) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Podusage) ProtoMessage() {} - -func (x *Podusage) ProtoReflect() protoreflect.Message { - mi := &file_noderpc_noderpc_proto_msgTypes[2] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Podusage.ProtoReflect.Descriptor instead. -func (*Podusage) Descriptor() ([]byte, []int) { - return file_noderpc_noderpc_proto_rawDescGZIP(), []int{2} -} - -func (x *Podusage) GetPoduuid() string { - if x != nil { - return x.Poduuid - } - return "" -} - -func (x *Podusage) GetPodvgpuinfo() *SharedRegionT { - if x != nil { - return x.Podvgpuinfo - } - return nil -} - -// The request message containing the user's name. -type GetNodeVGPURequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Ctruuid string `protobuf:"bytes,1,opt,name=ctruuid,proto3" json:"ctruuid,omitempty"` -} - -func (x *GetNodeVGPURequest) Reset() { - *x = GetNodeVGPURequest{} - if protoimpl.UnsafeEnabled { - mi := &file_noderpc_noderpc_proto_msgTypes[3] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *GetNodeVGPURequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetNodeVGPURequest) ProtoMessage() {} - -func (x *GetNodeVGPURequest) ProtoReflect() protoreflect.Message { - mi := &file_noderpc_noderpc_proto_msgTypes[3] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use GetNodeVGPURequest.ProtoReflect.Descriptor instead. -func (*GetNodeVGPURequest) Descriptor() ([]byte, []int) { - return file_noderpc_noderpc_proto_rawDescGZIP(), []int{3} -} - -func (x *GetNodeVGPURequest) GetCtruuid() string { - if x != nil { - return x.Ctruuid - } - return "" -} - -// The response message containing the greetings -type GetNodeVGPUReply struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Nodeid string `protobuf:"bytes,1,opt,name=nodeid,proto3" json:"nodeid,omitempty"` - Nodevgpuinfo []*Podusage `protobuf:"bytes,2,rep,name=nodevgpuinfo,proto3" json:"nodevgpuinfo,omitempty"` -} - -func (x *GetNodeVGPUReply) Reset() { - *x = GetNodeVGPUReply{} - if protoimpl.UnsafeEnabled { - mi := &file_noderpc_noderpc_proto_msgTypes[4] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *GetNodeVGPUReply) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetNodeVGPUReply) ProtoMessage() {} - -func (x *GetNodeVGPUReply) ProtoReflect() protoreflect.Message { - mi := &file_noderpc_noderpc_proto_msgTypes[4] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use GetNodeVGPUReply.ProtoReflect.Descriptor instead. -func (*GetNodeVGPUReply) Descriptor() ([]byte, []int) { - return file_noderpc_noderpc_proto_rawDescGZIP(), []int{4} -} - -func (x *GetNodeVGPUReply) GetNodeid() string { - if x != nil { - return x.Nodeid - } - return "" -} - -func (x *GetNodeVGPUReply) GetNodevgpuinfo() []*Podusage { - if x != nil { - return x.Nodevgpuinfo - } - return nil -} - -var File_noderpc_noderpc_proto protoreflect.FileDescriptor - -var file_noderpc_noderpc_proto_rawDesc = []byte{ - 0x0a, 0x15, 0x6e, 0x6f, 0x64, 0x65, 0x72, 0x70, 0x63, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x72, 0x70, - 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x09, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x72, - 0x70, 0x63, 0x22, 0x4f, 0x0a, 0x0f, 0x73, 0x68, 0x72, 0x72, 0x65, 0x67, 0x50, 0x72, 0x6f, 0x63, - 0x53, 0x6c, 0x6f, 0x74, 0x54, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x03, 0x70, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x64, 0x18, - 0x02, 0x20, 0x03, 0x28, 0x04, 0x52, 0x04, 0x75, 0x73, 0x65, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x73, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x22, 0xca, 0x01, 0x0a, 0x0d, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x52, 0x65, - 0x67, 0x69, 0x6f, 0x6e, 0x54, 0x12, 0x28, 0x0a, 0x0f, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, - 0x69, 0x7a, 0x65, 0x64, 0x46, 0x6c, 0x61, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, - 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x46, 0x6c, 0x61, 0x67, 0x12, - 0x1a, 0x0a, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x50, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0d, 0x52, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x50, 0x69, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x73, - 0x65, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x73, 0x65, 0x6d, 0x12, 0x14, 0x0a, - 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x04, 0x20, 0x03, 0x28, 0x04, 0x52, 0x05, 0x6c, 0x69, - 0x6d, 0x69, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x6d, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, - 0x05, 0x20, 0x03, 0x28, 0x04, 0x52, 0x07, 0x73, 0x6d, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x30, - 0x0a, 0x05, 0x70, 0x72, 0x6f, 0x63, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, - 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x73, 0x68, 0x72, 0x72, 0x65, 0x67, - 0x50, 0x72, 0x6f, 0x63, 0x53, 0x6c, 0x6f, 0x74, 0x54, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x63, 0x73, - 0x22, 0x60, 0x0a, 0x08, 0x70, 0x6f, 0x64, 0x75, 0x73, 0x61, 0x67, 0x65, 0x12, 0x18, 0x0a, 0x07, - 0x70, 0x6f, 0x64, 0x75, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, - 0x6f, 0x64, 0x75, 0x75, 0x69, 0x64, 0x12, 0x3a, 0x0a, 0x0b, 0x70, 0x6f, 0x64, 0x76, 0x67, 0x70, - 0x75, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x70, 0x6c, - 0x75, 0x67, 0x69, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x52, 0x65, - 0x67, 0x69, 0x6f, 0x6e, 0x54, 0x52, 0x0b, 0x70, 0x6f, 0x64, 0x76, 0x67, 0x70, 0x75, 0x69, 0x6e, - 0x66, 0x6f, 0x22, 0x2e, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x47, 0x50, - 0x55, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x74, 0x72, 0x75, - 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x74, 0x72, 0x75, 0x75, - 0x69, 0x64, 0x22, 0x63, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x47, 0x50, - 0x55, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x69, 0x64, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x69, 0x64, 0x12, 0x37, - 0x0a, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x76, 0x67, 0x70, 0x75, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x72, 0x70, 0x63, - 0x2e, 0x70, 0x6f, 0x64, 0x75, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x76, - 0x67, 0x70, 0x75, 0x69, 0x6e, 0x66, 0x6f, 0x32, 0x5b, 0x0a, 0x0c, 0x4e, 0x6f, 0x64, 0x65, 0x56, - 0x47, 0x50, 0x55, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x4b, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x4e, 0x6f, - 0x64, 0x65, 0x56, 0x47, 0x50, 0x55, 0x12, 0x1d, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x72, - 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x47, 0x50, 0x55, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x72, 0x70, - 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x47, 0x50, 0x55, 0x52, 0x65, 0x70, - 0x6c, 0x79, 0x22, 0x00, 0x42, 0x4b, 0x0a, 0x1b, 0x69, 0x6f, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, - 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x2e, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, - 0x72, 0x6c, 0x64, 0x42, 0x0f, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x50, - 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x19, 0x67, 0x69, 0x74, 0x6c, 0x61, 0x62, 0x2e, 0x34, - 0x70, 0x64, 0x2e, 0x69, 0x6f, 0x2f, 0x76, 0x47, 0x50, 0x55, 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, - 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, -} - -var ( - file_noderpc_noderpc_proto_rawDescOnce sync.Once - file_noderpc_noderpc_proto_rawDescData = file_noderpc_noderpc_proto_rawDesc -) - -func file_noderpc_noderpc_proto_rawDescGZIP() []byte { - file_noderpc_noderpc_proto_rawDescOnce.Do(func() { - file_noderpc_noderpc_proto_rawDescData = protoimpl.X.CompressGZIP(file_noderpc_noderpc_proto_rawDescData) - }) - return file_noderpc_noderpc_proto_rawDescData -} - -var file_noderpc_noderpc_proto_msgTypes = make([]protoimpl.MessageInfo, 5) -var file_noderpc_noderpc_proto_goTypes = []interface{}{ - (*ShrregProcSlotT)(nil), // 0: pluginrpc.shrregProcSlotT - (*SharedRegionT)(nil), // 1: pluginrpc.sharedRegionT - (*Podusage)(nil), // 2: pluginrpc.podusage - (*GetNodeVGPURequest)(nil), // 3: pluginrpc.GetNodeVGPURequest - (*GetNodeVGPUReply)(nil), // 4: pluginrpc.GetNodeVGPUReply -} -var file_noderpc_noderpc_proto_depIdxs = []int32{ - 0, // 0: pluginrpc.sharedRegionT.procs:type_name -> pluginrpc.shrregProcSlotT - 1, // 1: pluginrpc.podusage.podvgpuinfo:type_name -> pluginrpc.sharedRegionT - 2, // 2: pluginrpc.GetNodeVGPUReply.nodevgpuinfo:type_name -> pluginrpc.podusage - 3, // 3: pluginrpc.NodeVGPUInfo.GetNodeVGPU:input_type -> pluginrpc.GetNodeVGPURequest - 4, // 4: pluginrpc.NodeVGPUInfo.GetNodeVGPU:output_type -> pluginrpc.GetNodeVGPUReply - 4, // [4:5] is the sub-list for method output_type - 3, // [3:4] is the sub-list for method input_type - 3, // [3:3] is the sub-list for extension type_name - 3, // [3:3] is the sub-list for extension extendee - 0, // [0:3] is the sub-list for field type_name -} - -func init() { file_noderpc_noderpc_proto_init() } -func file_noderpc_noderpc_proto_init() { - if File_noderpc_noderpc_proto != nil { - return - } - if !protoimpl.UnsafeEnabled { - file_noderpc_noderpc_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ShrregProcSlotT); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_noderpc_noderpc_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SharedRegionT); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_noderpc_noderpc_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*Podusage); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_noderpc_noderpc_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetNodeVGPURequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_noderpc_noderpc_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetNodeVGPUReply); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - } - type x struct{} - out := protoimpl.TypeBuilder{ - File: protoimpl.DescBuilder{ - GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: file_noderpc_noderpc_proto_rawDesc, - NumEnums: 0, - NumMessages: 5, - NumExtensions: 0, - NumServices: 1, - }, - GoTypes: file_noderpc_noderpc_proto_goTypes, - DependencyIndexes: file_noderpc_noderpc_proto_depIdxs, - MessageInfos: file_noderpc_noderpc_proto_msgTypes, - }.Build() - File_noderpc_noderpc_proto = out.File - file_noderpc_noderpc_proto_rawDesc = nil - file_noderpc_noderpc_proto_goTypes = nil - file_noderpc_noderpc_proto_depIdxs = nil -} diff --git a/cmd/vGPUmonitor/noderpc/noderpc.proto b/cmd/vGPUmonitor/noderpc/noderpc.proto deleted file mode 100644 index 611c3ec..0000000 --- a/cmd/vGPUmonitor/noderpc/noderpc.proto +++ /dev/null @@ -1,61 +0,0 @@ -// Copyright 2015 gRPC authors. -// -// 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. - -syntax = "proto3"; - -option go_package = "gitlab.4pd.io/vGPUmonitor"; -option java_multiple_files = true; -option java_package = "io.grpc.examples.helloworld"; -option java_outer_classname = "HelloWorldProto"; - -package pluginrpc; - -// The greeting service definition. -service NodeVGPUInfo { - // Sends a greeting - rpc GetNodeVGPU (GetNodeVGPURequest) returns (GetNodeVGPUReply) {} -} - -// The sharedProcs contains the sharedRegion -message shrregProcSlotT { - int32 pid = 1; - repeated uint64 used = 2; - int32 status = 3; -} - -// The sharedRegionT struct is the main struct for monitoring vgpu -message sharedRegionT { - int32 initializedFlag = 1; - uint32 ownerPid = 2; - uint32 sem = 3; - repeated uint64 limit = 4; - repeated uint64 sm_limit = 5; - repeated shrregProcSlotT procs = 6; -} - -message podusage { - string poduuid = 1; - sharedRegionT podvgpuinfo = 2; -} - -// The request message containing the user's name. -message GetNodeVGPURequest { - string ctruuid = 1; -} - -// The response message containing the greetings -message GetNodeVGPUReply { - string nodeid = 1; - repeated podusage nodevgpuinfo = 2; -} diff --git a/cmd/vGPUmonitor/noderpc/noderpc_grpc.pb.go b/cmd/vGPUmonitor/noderpc/noderpc_grpc.pb.go deleted file mode 100644 index 346ed4c..0000000 --- a/cmd/vGPUmonitor/noderpc/noderpc_grpc.pb.go +++ /dev/null @@ -1,103 +0,0 @@ -// Code generated by protoc-gen-go-grpc. DO NOT EDIT. - -package vGPUmonitor - -import ( - context "context" - grpc "google.golang.org/grpc" - codes "google.golang.org/grpc/codes" - status "google.golang.org/grpc/status" -) - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 - -// NodeVGPUInfoClient is the client API for NodeVGPUInfo service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. -type NodeVGPUInfoClient interface { - // Sends a greeting - GetNodeVGPU(ctx context.Context, in *GetNodeVGPURequest, opts ...grpc.CallOption) (*GetNodeVGPUReply, error) -} - -type nodeVGPUInfoClient struct { - cc grpc.ClientConnInterface -} - -func NewNodeVGPUInfoClient(cc grpc.ClientConnInterface) NodeVGPUInfoClient { - return &nodeVGPUInfoClient{cc} -} - -func (c *nodeVGPUInfoClient) GetNodeVGPU(ctx context.Context, in *GetNodeVGPURequest, opts ...grpc.CallOption) (*GetNodeVGPUReply, error) { - out := new(GetNodeVGPUReply) - err := c.cc.Invoke(ctx, "/pluginrpc.NodeVGPUInfo/GetNodeVGPU", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -// NodeVGPUInfoServer is the server API for NodeVGPUInfo service. -// All implementations must embed UnimplementedNodeVGPUInfoServer -// for forward compatibility -type NodeVGPUInfoServer interface { - // Sends a greeting - GetNodeVGPU(context.Context, *GetNodeVGPURequest) (*GetNodeVGPUReply, error) - mustEmbedUnimplementedNodeVGPUInfoServer() -} - -// UnimplementedNodeVGPUInfoServer must be embedded to have forward compatible implementations. -type UnimplementedNodeVGPUInfoServer struct { -} - -func (UnimplementedNodeVGPUInfoServer) GetNodeVGPU(context.Context, *GetNodeVGPURequest) (*GetNodeVGPUReply, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetNodeVGPU not implemented") -} -func (UnimplementedNodeVGPUInfoServer) mustEmbedUnimplementedNodeVGPUInfoServer() {} - -// UnsafeNodeVGPUInfoServer may be embedded to opt out of forward compatibility for this service. -// Use of this interface is not recommended, as added methods to NodeVGPUInfoServer will -// result in compilation errors. -type UnsafeNodeVGPUInfoServer interface { - mustEmbedUnimplementedNodeVGPUInfoServer() -} - -func RegisterNodeVGPUInfoServer(s grpc.ServiceRegistrar, srv NodeVGPUInfoServer) { - s.RegisterService(&NodeVGPUInfo_ServiceDesc, srv) -} - -func _NodeVGPUInfo_GetNodeVGPU_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetNodeVGPURequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(NodeVGPUInfoServer).GetNodeVGPU(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pluginrpc.NodeVGPUInfo/GetNodeVGPU", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(NodeVGPUInfoServer).GetNodeVGPU(ctx, req.(*GetNodeVGPURequest)) - } - return interceptor(ctx, in, info, handler) -} - -// NodeVGPUInfo_ServiceDesc is the grpc.ServiceDesc for NodeVGPUInfo service. -// It's only intended for direct use with grpc.RegisterService, -// and not to be introspected or modified (even as a copy) -var NodeVGPUInfo_ServiceDesc = grpc.ServiceDesc{ - ServiceName: "pluginrpc.NodeVGPUInfo", - HandlerType: (*NodeVGPUInfoServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "GetNodeVGPU", - Handler: _NodeVGPUInfo_GetNodeVGPU_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "noderpc/noderpc.proto", -} diff --git a/cmd/vGPUmonitor/pathmonitor.go b/cmd/vGPUmonitor/pathmonitor.go index f319b74..d3a7b6b 100644 --- a/cmd/vGPUmonitor/pathmonitor.go +++ b/cmd/vGPUmonitor/pathmonitor.go @@ -20,19 +20,15 @@ import ( "context" "errors" "fmt" - "net" "os" "path/filepath" "strings" "sync" "time" - "google.golang.org/grpc" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/klog/v2" - - vGPUmonitor "volcano.sh/k8s-device-plugin/cmd/vGPUmonitor/noderpc" ) type podusage struct { @@ -153,24 +149,3 @@ func monitorPath(podmap map[string]podusage) error { klog.Infof("Monitored path map: %v", podmap) return nil } - -type server struct { - vGPUmonitor.UnimplementedNodeVGPUInfoServer -} - -func serveInfo(ch chan error) { - s := grpc.NewServer() - lis, err := net.Listen("tcp", ":9395") - if err != nil { - ch <- fmt.Errorf("failed to listen: %v", err) - // return respect the error, so the goroutine can end - return - } - vGPUmonitor.RegisterNodeVGPUInfoServer(s, &server{}) - klog.Infof("server listening at %v", lis.Addr()) - if err = s.Serve(lis); err != nil { - ch <- fmt.Errorf("failed to serve: %v", err) - // return respect the error, so the goroutine can end - return - } -} From 567494c4dcd7b3b0532e9995555fa0ed56cd429a Mon Sep 17 00:00:00 2001 From: zhitianli Date: Fri, 9 Aug 2024 16:53:52 +0800 Subject: [PATCH 3/3] add description of how to collect device-plugin's metrics --- README.md | 7 +++++++ doc/vgpu_device_plugin_metrics.png | Bin 0 -> 322404 bytes 2 files changed, 7 insertions(+) create mode 100644 doc/vgpu_device_plugin_metrics.png diff --git a/README.md b/README.md index cfcd3e4..6e897ae 100644 --- a/README.md +++ b/README.md @@ -188,6 +188,13 @@ volcano-scheduler-metrics records every GPU usage and limitation, visit the foll curl {volcano scheduler cluster ip}:8080/metrics ``` +You can also collect the **GPU utilization**, **GPU memory usage**, **pods' GPU memory limitations** and **pods' GPU memory usage** metrics on nodes by visiting the following addresses: + +``` +curl {volcano device plugin cluster ip}:9394/metrics +``` +![img](./doc/vgpu_device_plugin_metrics.png) + # Issues and Contributing [Checkout the Contributing document!](CONTRIBUTING.md) diff --git a/doc/vgpu_device_plugin_metrics.png b/doc/vgpu_device_plugin_metrics.png new file mode 100644 index 0000000000000000000000000000000000000000..6b1fde9af85b16b84e9c7a91425f4ce1a6174cb8 GIT binary patch literal 322404 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%0DK<1a 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%0D$R-2liDP@w^RIl50Y0?|F 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 KZ%U;;`29b84qXNS literal 0 HcmV?d00001