diff --git a/Makefile b/Makefile index 08b4a646..33a2403c 100644 --- a/Makefile +++ b/Makefile @@ -144,31 +144,31 @@ $(PKG_BINDINGS_DIR)/nvml.h: $(GEN_BINDINGS_DIR)/nvml.h | $(PKG_BINDINGS_DIR) $(SED) -i -E 's#(typedef\s+struct)\s+(nvml.*_st\*)\s+(nvml.*_t);#\1\n{\n struct \2 handle;\n} \3;#g' $(@) spatch --in-place --very-quiet --sp-file $(GEN_BINDINGS_DIR)/anonymous_structs.cocci $(@) > /dev/null -bindings: .create-bindings .strip-autogen-comment .strip-nvml-h-linenumber +bindings: .create-bindings .generate-dispatch .transform-bindings .generate-api .create-bindings: $(PKG_BINDINGS_DIR)/nvml.h $(SOURCES) | $(PKG_BINDINGS_DIR) - cp $(GEN_BINDINGS_DIR)/nvml.yml $(PKG_BINDINGS_DIR) - c-for-go -out $(PKG_DIR) $(PKG_BINDINGS_DIR)/nvml.yml + c-for-go -out $(PKG_DIR) $(GEN_BINDINGS_DIR)/nvml.yml cd $(PKG_BINDINGS_DIR); \ go tool cgo -godefs types.go > types_gen.go; \ go fmt types_gen.go; \ cd -> /dev/null - rm -rf $(PKG_BINDINGS_DIR)/nvml.yml $(PKG_BINDINGS_DIR)/cgo_helpers.go $(PKG_BINDINGS_DIR)/types.go $(PKG_BINDINGS_DIR)/_obj - go run $(GEN_BINDINGS_DIR)/generateapi.go \ + rm -rf $(PKG_BINDINGS_DIR)/cgo_helpers.go $(PKG_BINDINGS_DIR)/types.go $(PKG_BINDINGS_DIR)/_obj $(PKG_BINDINGS_DIR)/_cgo_2.o + +.generate-dispatch: | .create-bindings + go run $(GEN_BINDINGS_DIR)/generate-dispatch \ + -header $(GEN_BINDINGS_DIR)/nvml.h \ + -output-h $(PKG_BINDINGS_DIR)/nvml_dispatch.h \ + -output-go $(PKG_BINDINGS_DIR)/zz_generated_nvml_dispatch.go + +.transform-bindings: | .generate-dispatch + go run $(GEN_BINDINGS_DIR)/transformbindings \ + --sourceDir $(PKG_BINDINGS_DIR) + +.generate-api: | .transform-bindings + go run $(GEN_BINDINGS_DIR)/generateapi \ --sourceDir $(PKG_BINDINGS_DIR) \ --output $(PKG_BINDINGS_DIR)/zz_generated.api.go make fmt -.strip-autogen-comment: SED_SEARCH_STRING := // WARNING: This file has automatically been generated on -.strip-autogen-comment: SED_REPLACE_STRING := // WARNING: THIS FILE WAS AUTOMATICALLY GENERATED. -.strip-autogen-comment: | .create-bindings - grep -l -R "$(SED_SEARCH_STRING)" pkg \ - | xargs $(SED) -i -E 's#$(SED_SEARCH_STRING).*$$#$(SED_REPLACE_STRING)#g' - -.strip-nvml-h-linenumber: SED_SEARCH_STRING := // (.*) nvml/nvml.h:[0-9]+ -.strip-nvml-h-linenumber: SED_REPLACE_STRING := // \1 nvml/nvml.h -.strip-nvml-h-linenumber: | .create-bindings - grep -l -RE "$(SED_SEARCH_STRING)" pkg \ - | xargs $(SED) -i -E 's#$(SED_SEARCH_STRING)$$#$(SED_REPLACE_STRING)#g' test-bindings: bindings clean-bindings: @@ -178,6 +178,8 @@ clean-bindings: rm -f $(PKG_BINDINGS_DIR)/doc.go rm -f $(PKG_BINDINGS_DIR)/nvml.go rm -f $(PKG_BINDINGS_DIR)/nvml.h + rm -f $(PKG_BINDINGS_DIR)/nvml_dispatch.h + rm -f $(PKG_BINDINGS_DIR)/zz_generated_nvml_dispatch.go rm -f $(PKG_BINDINGS_DIR)/types_gen.go rm -f $(PKG_BINDINGS_DIR)/zz_generated.api.go diff --git a/gen/nvml/generate-dispatch/main.go b/gen/nvml/generate-dispatch/main.go new file mode 100644 index 00000000..61a8f962 --- /dev/null +++ b/gen/nvml/generate-dispatch/main.go @@ -0,0 +1,357 @@ +// Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// gen-dispatch generates a C dispatch table for NVML functions. +// +// It reads nvml.h and emits: +// - nvml_dispatch.h: struct definition + static inline call-through wrappers +// - zz_generated_nvml_dispatch.go: Go functions populateDispatch / clearDispatch +package main + +import ( + "bufio" + "flag" + "fmt" + "os" + "regexp" + "strings" +) + +var ( + headerInput = flag.String("header", "", "path to nvml.h (required)") + outputH = flag.String("output-h", "", "output C header path (required)") + outputGo = flag.String("output-go", "", "output Go source path (required)") + goPackage = flag.String("package", "nvml", "Go package name for the generated file") +) + +// funcDecl holds a parsed C function declaration. +type funcDecl struct { + ReturnType string + Name string + rawParams string + params []param +} + +type param struct { + typ string + name string +} + +var declDirRe = regexp.MustCompile(`\bDECLDIR\b`) +var deprecatedRe = regexp.MustCompile(`^DEPRECATED\([^)]*\)\s*`) + +func main() { + flag.Parse() + if *headerInput == "" || *outputH == "" || *outputGo == "" { + fmt.Fprintln(os.Stderr, "usage: gen-dispatch -header -output-h -output-go ") + os.Exit(1) + } + + decls, err := parseHeader(*headerInput) + if err != nil { + fmt.Fprintf(os.Stderr, "error parsing header: %v\n", err) + os.Exit(1) + } + + if err := writeHeader(*outputH, decls); err != nil { + fmt.Fprintf(os.Stderr, "error writing %s: %v\n", *outputH, err) + os.Exit(1) + } + if err := writeGoDispatch(*outputGo, decls); err != nil { + fmt.Fprintf(os.Stderr, "error writing %s: %v\n", *outputGo, err) + os.Exit(1) + } + + fmt.Printf("Generated %s, %s (%d functions)\n", *outputH, *outputGo, len(decls)) +} + +// parseHeader reads nvml.h and extracts all DECLDIR function declarations. +func parseHeader(path string) ([]funcDecl, error) { + f, err := os.Open(path) + if err != nil { + return nil, err + } + defer f.Close() + + var lines []string + scanner := bufio.NewScanner(f) + var buf string + for scanner.Scan() { + line := strings.TrimRight(scanner.Text(), " \t") + if buf != "" { + buf += " " + strings.TrimSpace(line) + if strings.Contains(line, ";") { + lines = append(lines, buf) + buf = "" + } + continue + } + if declDirRe.MatchString(line) && !strings.HasPrefix(line, "#") { + if strings.Contains(line, ";") { + lines = append(lines, line) + } else { + buf = line + } + } + } + if err := scanner.Err(); err != nil { + return nil, err + } + + var decls []funcDecl + for _, line := range lines { + d, ok := parseLine(line) + if !ok { + continue + } + decls = append(decls, d) + } + return decls, nil +} + +func parseLine(line string) (funcDecl, bool) { + line = deprecatedRe.ReplaceAllString(line, "") + line = strings.ReplaceAll(line, "DECLDIR", "") + line = strings.TrimSuffix(strings.TrimSpace(line), ";") + line = collapseSpaces(line) + + parenOpen := strings.Index(line, "(") + if parenOpen < 0 { + return funcDecl{}, false + } + parenClose := strings.LastIndex(line, ")") + if parenClose < parenOpen { + return funcDecl{}, false + } + + beforeParen := strings.TrimSpace(line[:parenOpen]) + rawParams := strings.TrimSpace(line[parenOpen+1 : parenClose]) + + lastSpace := strings.LastIndex(beforeParen, " ") + if lastSpace < 0 { + return funcDecl{}, false + } + retType := strings.TrimSpace(beforeParen[:lastSpace]) + name := strings.TrimSpace(beforeParen[lastSpace+1:]) + + if !strings.HasPrefix(name, "nvml") { + return funcDecl{}, false + } + + var params []param + if rawParams != "" && rawParams != "void" { + for _, p := range splitParams(rawParams) { + p = strings.TrimSpace(p) + if p == "" { + continue + } + pt, pn := parseParam(p) + params = append(params, param{typ: pt, name: pn}) + } + } + + return funcDecl{ + ReturnType: retType, + Name: name, + params: params, + }, true +} + +func splitParams(s string) []string { + var result []string + depth := 0 + start := 0 + for i, ch := range s { + switch ch { + case '(': + depth++ + case ')': + depth-- + case ',': + if depth == 0 { + result = append(result, s[start:i]) + start = i + 1 + } + } + } + return append(result, s[start:]) +} + +func parseParam(p string) (typ, name string) { + tokens := strings.Fields(p) + if len(tokens) == 0 { + return p, "" + } + last := tokens[len(tokens)-1] + name = strings.TrimLeft(last, "*") + stars := last[:len(last)-len(name)] + typeTokens := tokens[:len(tokens)-1] + if stars != "" { + typeTokens = append(typeTokens, stars) + } + return strings.Join(typeTokens, " "), name +} + +func collapseSpaces(s string) string { + return regexp.MustCompile(`\s+`).ReplaceAllString(s, " ") +} + +// ---- Header ---------------------------------------------------------------- + +const headerTemplate = `// Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// WARNING: THIS FILE WAS AUTOMATICALLY GENERATED. +// Code generated by gen/nvml/gen-dispatch. DO NOT EDIT. + +#ifndef NVML_DISPATCH_H +#define NVML_DISPATCH_H + +#include "nvml.h" + +// nvml_dispatch_t holds function pointers for all NVML API functions. +// Populated at library load time via populateDispatch() in Go. +typedef struct { +%s +} nvml_dispatch_t; + +extern nvml_dispatch_t nvml_dispatch; + +// Static inline wrappers — cgo calls these instead of the NVML symbols directly, +// routing through the dispatch table rather than the PLT. +%s +#endif /* NVML_DISPATCH_H */ +` + +func writeHeader(path string, decls []funcDecl) error { + var structFields strings.Builder + var inlineWrappers strings.Builder + + for _, d := range decls { + fmt.Fprintf(&structFields, " %s (*%s)(%s);\n", + d.ReturnType, d.Name, paramList(d, true)) + + fmt.Fprintf(&inlineWrappers, "static inline %s dispatch_%s(%s) {\n", + d.ReturnType, d.Name, paramList(d, true)) + switch d.ReturnType { + case "void": + fmt.Fprintf(&inlineWrappers, " if (!nvml_dispatch.%s) return;\n", d.Name) + fmt.Fprintf(&inlineWrappers, " nvml_dispatch.%s(%s);\n", d.Name, argList(d)) + case "nvmlReturn_t": + fmt.Fprintf(&inlineWrappers, " if (!nvml_dispatch.%s) return NVML_ERROR_FUNCTION_NOT_FOUND;\n", d.Name) + fmt.Fprintf(&inlineWrappers, " return nvml_dispatch.%s(%s);\n", d.Name, argList(d)) + default: + fmt.Fprintf(&inlineWrappers, " if (!nvml_dispatch.%s) return (%s)0;\n", d.Name, d.ReturnType) + fmt.Fprintf(&inlineWrappers, " return nvml_dispatch.%s(%s);\n", d.Name, argList(d)) + } + inlineWrappers.WriteString("}\n\n") + } + + return os.WriteFile(path, []byte(fmt.Sprintf(headerTemplate, + structFields.String(), inlineWrappers.String())), 0644) +} + +// ---- Go dispatch file ------------------------------------------------------ + +const goTemplate = `// Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// WARNING: THIS FILE WAS AUTOMATICALLY GENERATED. +// Code generated by gen/nvml/gen-dispatch. DO NOT EDIT. + +package %s + +/* +#include "nvml_dispatch.h" + +// nvml_dispatch is the single global instance of the dispatch table. +// It is populated by populateDispatch() and zeroed by clearDispatch() in Go. +nvml_dispatch_t nvml_dispatch; +*/ +import "C" +import ( + "unsafe" + + "github.com/NVIDIA/go-nvml/pkg/dl" +) + +// populateDispatch resolves all NVML function pointers via the given library +// and stores them in the C dispatch table. +func populateDispatch(lib *dl.DynamicLibrary) error { +%s return nil +} + +// clearDispatch zeros the dispatch table, preventing calls into an unloaded library. +func clearDispatch(_ *dl.DynamicLibrary) error { + C.nvml_dispatch = C.nvml_dispatch_t{} + return nil +} +` + +func writeGoDispatch(path string, decls []funcDecl) error { + var populate strings.Builder + for _, d := range decls { + fmt.Fprintf(&populate, + "\t*(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.%s)) = lib.Resolve(%q)\n", + d.Name, d.Name) + } + return os.WriteFile(path, []byte(fmt.Sprintf(goTemplate, *goPackage, populate.String())), 0644) +} + +// ---- helpers --------------------------------------------------------------- + +func paramList(d funcDecl, withNames bool) string { + if len(d.params) == 0 { + return "void" + } + var parts []string + for _, p := range d.params { + if withNames && p.name != "" { + parts = append(parts, p.typ+" "+p.name) + } else { + parts = append(parts, p.typ) + } + } + return strings.Join(parts, ", ") +} + +func argList(d funcDecl) string { + var names []string + for _, p := range d.params { + names = append(names, p.name) + } + return strings.Join(names, ", ") +} diff --git a/gen/nvml/generateapi/generateapi.go b/gen/nvml/generateapi/generateapi.go new file mode 100644 index 00000000..8428b91d --- /dev/null +++ b/gen/nvml/generateapi/generateapi.go @@ -0,0 +1,420 @@ +/** +# Copyright 2024 NVIDIA CORPORATION +# +# 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 ( + "flag" + "fmt" + "go/ast" + "go/parser" + "go/token" + "io" + "io/fs" + "os" + "path/filepath" + "slices" + "sort" + "strings" + "unicode" +) + +type GeneratableInterfacePoperties struct { + Type string + Interface string + Exclude []string + PackageMethodsAliasedFrom string +} + +var GeneratableInterfaces = []GeneratableInterfacePoperties{ + { + Type: "library", + Interface: "Interface", + Exclude: []string{"LookupSymbol"}, + PackageMethodsAliasedFrom: "libnvml", + }, + { + Type: "nvmlDevice", + Interface: "Device", + }, + { + Type: "nvmlGpuInstance", + Interface: "GpuInstance", + }, + { + Type: "nvmlComputeInstance", + Interface: "ComputeInstance", + }, + { + Type: "nvmlEventSet", + Interface: "EventSet", + }, + { + Type: "nvmlGpmSample", + Interface: "GpmSample", + }, + { + Type: "nvmlUnit", + Interface: "Unit", + }, + { + Type: "nvmlVgpuInstance", + Interface: "VgpuInstance", + }, + { + Type: "nvmlVgpuTypeId", + Interface: "VgpuTypeId", + }, +} + +func main() { + sourceDir := flag.String("sourceDir", "", "Path to the source directory for all go files") + output := flag.String("output", "", "Path to the output file (default: stdout)") + flag.Parse() + + // Check if required flags are provided + if *sourceDir == "" { + flag.Usage() + return + } + + writer, closer, err := getWriter(*output) + if err != nil { + fmt.Printf("Error: %v", err) + return + } + defer closer() + + header, err := generateHeader() + if err != nil { + fmt.Printf("Error: %v", err) + return + } + fmt.Fprint(writer, header) + + for i, p := range GeneratableInterfaces { + if p.PackageMethodsAliasedFrom != "" { + comment, err := generatePackageMethodsComment(p) + if err != nil { + fmt.Printf("Error: %v", err) + return + } + fmt.Fprint(writer, comment) + + output, err := generatePackageMethods(*sourceDir, p) + if err != nil { + fmt.Printf("Error: %v", err) + return + } + fmt.Fprintf(writer, "%s\n", output) + } + + comment, err := generateInterfaceComment(p) + if err != nil { + fmt.Printf("Error: %v", err) + return + } + fmt.Fprint(writer, comment) + + output, err := generateInterface(*sourceDir, p) + if err != nil { + fmt.Printf("Error: %v", err) + return + } + fmt.Fprint(writer, output) + + if i < (len(GeneratableInterfaces) - 1) { + fmt.Fprint(writer, "\n") + } + } +} + +func getWriter(outputFile string) (io.Writer, func() error, error) { + if outputFile == "" { + return os.Stdout, func() error { return nil }, nil + } + + file, err := os.Create(outputFile) + if err != nil { + return nil, nil, err + } + + return file, file.Close, nil +} + +func generateHeader() (string, error) { + lines := []string{ + "/**", + "# Copyright 2024 NVIDIA CORPORATION", + "#", + "# 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.", + "**/", + "", + "// Generated Code; DO NOT EDIT.", + "", + "package nvml", + "", + "", + } + return strings.Join(lines, "\n"), nil +} + +func generatePackageMethodsComment(input GeneratableInterfacePoperties) (string, error) { + commentFmt := []string{ + "// The variables below represent package level methods from the %s type.", + } + + var signature strings.Builder + comment := strings.Join(commentFmt, "\n") + comment = fmt.Sprintf(comment, input.Type) + fmt.Fprintf(&signature, "%s\n", comment) + return signature.String(), nil +} + +func generateInterfaceComment(input GeneratableInterfacePoperties) (string, error) { + commentFmt := []string{ + "// %s represents the interface for the %s type.", + "//", + "//go:generate moq -out mock/%s.go -pkg mock . %s:%s", + } + + var signature strings.Builder + comment := strings.Join(commentFmt, "\n") + comment = fmt.Sprintf(comment, input.Interface, input.Type, strings.ToLower(input.Interface), input.Interface, input.Interface) + fmt.Fprintf(&signature, "%s\n", comment) + return signature.String(), nil +} + +func generatePackageMethods(sourceDir string, input GeneratableInterfacePoperties) (string, error) { + var signature strings.Builder + + signature.WriteString("var (\n") + + methods, err := extractMethodsFromPackage(sourceDir, input) + if err != nil { + return "", err + } + + for _, method := range methods { + name := method.Name.Name + formatted := fmt.Sprintf("\t%s = %s.%s\n", name, input.PackageMethodsAliasedFrom, name) + signature.WriteString(formatted) + } + + signature.WriteString(")\n") + + return signature.String(), nil +} + +func generateInterface(sourceDir string, input GeneratableInterfacePoperties) (string, error) { + var signature strings.Builder + + fmt.Fprintf(&signature, "type %s interface {\n", input.Interface) + + methods, err := extractMethodsFromPackage(sourceDir, input) + if err != nil { + return "", err + } + + for _, method := range methods { + formatted := fmt.Sprintf("\t%s\n", formatMethodSignature(method)) + signature.WriteString(formatted) + } + + signature.WriteString("}\n") + + return signature.String(), nil +} + +func getGoFiles(sourceDir string) (map[string][]byte, error) { + gofiles := make(map[string][]byte) + + err := filepath.WalkDir(sourceDir, func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + if d.IsDir() || filepath.Ext(path) != ".go" { + return nil + } + + content, err := os.ReadFile(path) + if err != nil { + return err + } + + gofiles[path] = content + + return nil + }) + if err != nil { + return nil, fmt.Errorf("walking %s: %w", sourceDir, err) + } + + return gofiles, nil +} + +func extractMethodsFromPackage(sourceDir string, input GeneratableInterfacePoperties) ([]*ast.FuncDecl, error) { + gofiles, err := getGoFiles(sourceDir) + if err != nil { + return nil, err + } + + var methods []*ast.FuncDecl + for file, content := range gofiles { + m, err := extractMethods(file, content, input) + if err != nil { + return nil, err + } + methods = append(methods, m...) + } + + sort.Slice(methods, func(i, j int) bool { + return methods[i].Name.Name < methods[j].Name.Name + }) + + return methods, nil +} + +func extractMethods(sourceFile string, sourceContent []byte, input GeneratableInterfacePoperties) ([]*ast.FuncDecl, error) { + // Parse source file + fset := token.NewFileSet() + node, err := parser.ParseFile(fset, sourceFile, sourceContent, parser.ParseComments) + if err != nil { + return nil, err + } + + // Traverse AST to find type declarations and associated methods + var methods []*ast.FuncDecl + for _, decl := range node.Decls { + funcDecl, ok := decl.(*ast.FuncDecl) + if !ok { + continue + } + + // Check if the function is a method associated with the specified type + if receiverType := funcDecl.Recv; receiverType != nil { + var ident *ast.Ident + + for _, field := range receiverType.List { + switch fieldType := field.Type.(type) { + case *ast.Ident: + ident = fieldType + case *ast.StarExpr: + // Update ident if it's a *ast.StarExpr + if newIdent, ok := fieldType.X.(*ast.Ident); ok { + // If the inner type is an *ast.Ident, update ident + ident = newIdent + } + } + + // No identifier found + if ident == nil { + continue + } + + // Identifier is not the one we are looking for + if ident.Name != input.Type { + continue + } + + // Ignore non-public methods + if !isPublic(funcDecl.Name.Name) { + continue + } + + // Ignore method in the exclude list + if slices.Contains(input.Exclude, funcDecl.Name.Name) { + continue + } + + methods = append(methods, funcDecl) + } + } + } + + return methods, nil +} + +func formatMethodSignature(decl *ast.FuncDecl) string { + var signature strings.Builder + + // Write method name + signature.WriteString(decl.Name.Name) + signature.WriteString("(") + + // Write parameters + if decl.Type.Params != nil { + for i, param := range decl.Type.Params.List { + if i > 0 { + signature.WriteString(", ") + } + signature.WriteString(formatFieldList(param)) + } + } + + signature.WriteString(")") + + // Write return types + if decl.Type.Results != nil { + signature.WriteString(" ") + if len(decl.Type.Results.List) > 1 { + signature.WriteString("(") + } + for i, result := range decl.Type.Results.List { + if i > 0 { + signature.WriteString(", ") + } + signature.WriteString(formatFieldList(result)) + } + if len(decl.Type.Results.List) > 1 { + signature.WriteString(")") + } + } + + return signature.String() +} + +func formatFieldList(field *ast.Field) string { + var builder strings.Builder + switch fieldType := field.Type.(type) { + case *ast.Ident: + builder.WriteString(fieldType.Name) + case *ast.ArrayType: + builder.WriteString("[]") + builder.WriteString(formatFieldList(&ast.Field{Type: fieldType.Elt})) + case *ast.StarExpr: + builder.WriteString("*") + builder.WriteString(formatFieldList(&ast.Field{Type: fieldType.X})) + } + return builder.String() +} + +func isPublic(name string) bool { + if len(name) == 0 { + return false + } + return unicode.IsUpper([]rune(name)[0]) +} diff --git a/gen/nvml/nvml.yml b/gen/nvml/nvml.yml index bde540dd..d3d90863 100644 --- a/gen/nvml/nvml.yml +++ b/gen/nvml/nvml.yml @@ -32,8 +32,6 @@ GENERATOR: limitations under the License. Includes: ["nvml.h"] FlagGroups: - - {name: "LDFLAGS", traits: ["linux"], flags: ["-Wl,--export-dynamic","-Wl,--unresolved-symbols=ignore-in-object-files"]} - - {name: "LDFLAGS", traits: ["darwin"], flags: ["-Wl,-undefined,dynamic_lookup"]} - {name: "CFLAGS", flags: ["-DNVML_NO_UNVERSIONED_FUNC_DEFS=1"]} PARSER: SourcesPaths: ["nvml.h"] diff --git a/gen/nvml/transformbindings/transformbindings.go b/gen/nvml/transformbindings/transformbindings.go new file mode 100644 index 00000000..3d189653 --- /dev/null +++ b/gen/nvml/transformbindings/transformbindings.go @@ -0,0 +1,131 @@ +/** +# Copyright 2025 NVIDIA CORPORATION +# +# 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 ( + "flag" + "fmt" + "io/fs" + "os" + "path/filepath" + "regexp" + "strings" +) + +var ( + reAutogenComment = regexp.MustCompile(`(?m)// WARNING: This file has automatically been generated on.*$`) + reNvmlHLineNumber = regexp.MustCompile(`(?m)(// .* nvml/nvml\.h):[0-9]+$`) + reNvmlCall = regexp.MustCompile(`C\.(nvml[A-Za-z0-9_]+)\(`) +) + +func main() { + sourceDir := flag.String("sourceDir", "", "Path to directory containing generated bindings") + flag.Parse() + + if *sourceDir == "" { + flag.Usage() + os.Exit(1) + } + + if err := transformFiles(*sourceDir); err != nil { + fmt.Fprintf(os.Stderr, "Error: %v\n", err) + os.Exit(1) + } +} + +func transformFiles(sourceDir string) error { + return filepath.WalkDir(sourceDir, func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + ext := filepath.Ext(path) + if d.IsDir() || (ext != ".go" && ext != ".h") { + return nil + } + + content, err := os.ReadFile(path) + if err != nil { + return err + } + + transformed := applyGeneralTransforms(content) + if filepath.Base(path) == "nvml.go" { + transformed = []byte(applyNvmlGoTransforms(string(transformed))) + } + + if string(transformed) == string(content) { + return nil + } + return os.WriteFile(path, transformed, 0644) + }) +} + +func applyGeneralTransforms(content []byte) []byte { + content = reAutogenComment.ReplaceAll(content, []byte("// WARNING: THIS FILE WAS AUTOMATICALLY GENERATED.")) + content = reNvmlHLineNumber.ReplaceAll(content, []byte("$1")) + return content +} + +func applyNvmlGoTransforms(src string) string { + src = stripLDFlags(src) + src = rewriteCalls(src) + src = insertDispatchInclude(src) + return src +} + +func stripLDFlags(src string) string { + var out strings.Builder + for _, line := range strings.SplitAfter(src, "\n") { + trimmed := strings.TrimSpace(line) + if strings.HasPrefix(trimmed, "#cgo") && strings.Contains(trimmed, "LDFLAGS:") { + continue + } + out.WriteString(line) + } + return out.String() +} + +func rewriteCalls(src string) string { + return reNvmlCall.ReplaceAllStringFunc(src, func(match string) string { + return "C.dispatch_" + match[len("C."):] + }) +} + +func insertDispatchInclude(src string) string { + const dispatchInclude = `#include "nvml_dispatch.h"` + if strings.Contains(src, dispatchInclude) { + return src + } + + importC := `import "C"` + importIdx := strings.Index(src, importC) + if importIdx < 0 { + return src + } + preamble := src[:importIdx] + lastInclude := strings.LastIndex(preamble, "#include") + if lastInclude < 0 { + return src + } + lineEnd := strings.Index(preamble[lastInclude:], "\n") + if lineEnd < 0 { + return src + } + insertAt := lastInclude + lineEnd + 1 + + return preamble[:insertAt] + dispatchInclude + "\n" + src[insertAt:] +} diff --git a/pkg/dl/dl.go b/pkg/dl/dl.go index 494ca82f..e916cde2 100644 --- a/pkg/dl/dl.go +++ b/pkg/dl/dl.go @@ -36,18 +36,43 @@ const ( RTLD_NOLOAD = C.RTLD_NOLOAD ) +// Option is a functional option for configuring a DynamicLibrary. +type Option func(*DynamicLibrary) + +// WithAfterOpen registers a hook that is called after a successful Open. +// If the hook returns an error, Open fails and the library is closed. +func WithAfterOpen(hook func(*DynamicLibrary) error) Option { + return func(dl *DynamicLibrary) { + dl.afterOpen = hook + } +} + +// WithBeforeClose registers a hook that is called just before the library is +// unloaded by Close. +func WithBeforeClose(hook func(*DynamicLibrary) error) Option { + return func(dl *DynamicLibrary) { + dl.beforeClose = hook + } +} + type DynamicLibrary struct { - Name string - Flags int - handle unsafe.Pointer - path string + Name string + Flags int + handle unsafe.Pointer + path string + afterOpen func(*DynamicLibrary) error + beforeClose func(*DynamicLibrary) error } -func New(name string, flags int) *DynamicLibrary { - return (&DynamicLibrary{ +func New(name string, flags int, opts ...Option) *DynamicLibrary { + dl := &DynamicLibrary{ Name: name, Flags: flags, - }).init() + } + for _, opt := range opts { + opt(dl) + } + return dl.init() } func (dl *DynamicLibrary) reset() { @@ -94,6 +119,13 @@ func (dl *DynamicLibrary) Open() error { }); err != nil { return err } + + if dl.afterOpen != nil { + if err := dl.afterOpen(dl); err != nil { + _ = dl.Close() + return err + } + } return nil } @@ -101,6 +133,13 @@ func (dl *DynamicLibrary) Close() error { if dl.handle == nil { return nil } + + if dl.beforeClose != nil { + if err := dl.beforeClose(dl); err != nil { + return err + } + } + if err := withOSLock(func() error { if C.dlclose(dl.handle) != 0 { return dlError() @@ -113,6 +152,21 @@ func (dl *DynamicLibrary) Close() error { return nil } +// Resolve looks up symbol in the library and returns its address, or nil if +// not found. It implements the Resolver interface. +func (dl *DynamicLibrary) Resolve(symbol string) unsafe.Pointer { + sym := C.CString(symbol) + defer C.free(unsafe.Pointer(sym)) + + var ptr unsafe.Pointer + _ = withOSLock(func() error { + _ = dlError() // clear any previous error + ptr = C.dlsym(dl.handle, sym) + return nil + }) + return ptr +} + func (dl *DynamicLibrary) Lookup(symbol string) error { sym := C.CString(symbol) defer C.free(unsafe.Pointer(sym)) diff --git a/pkg/nvml/const.go b/pkg/nvml/const.go index 8a6a93c2..db7a7361 100644 --- a/pkg/nvml/const.go +++ b/pkg/nvml/const.go @@ -18,8 +18,6 @@ package nvml /* -#cgo linux LDFLAGS: -Wl,--export-dynamic -Wl,--unresolved-symbols=ignore-in-object-files -#cgo darwin LDFLAGS: -Wl,-undefined,dynamic_lookup #cgo CFLAGS: -DNVML_NO_UNVERSIONED_FUNC_DEFS=1 #include "nvml.h" #include diff --git a/pkg/nvml/lib.go b/pkg/nvml/lib.go index 5a7e6882..29a4e1b7 100644 --- a/pkg/nvml/lib.go +++ b/pkg/nvml/lib.go @@ -82,7 +82,10 @@ func (l *library) init(opts ...LibraryOption) { } l.path = o.path - l.dl = dl.New(o.path, o.flags) + l.dl = dl.New(o.path, o.flags, + dl.WithAfterOpen(populateDispatch), + dl.WithBeforeClose(clearDispatch), + ) } func (l *library) Extensions() ExtendedInterface { diff --git a/pkg/nvml/nvml.go b/pkg/nvml/nvml.go index 38123a96..28469aeb 100644 --- a/pkg/nvml/nvml.go +++ b/pkg/nvml/nvml.go @@ -18,19 +18,18 @@ package nvml /* -#cgo linux LDFLAGS: -Wl,--export-dynamic -Wl,--unresolved-symbols=ignore-in-object-files -#cgo darwin LDFLAGS: -Wl,-undefined,dynamic_lookup #cgo CFLAGS: -DNVML_NO_UNVERSIONED_FUNC_DEFS=1 #include "nvml.h" #include #include "cgo_helpers.h" +#include "nvml_dispatch.h" */ import "C" import "unsafe" // nvmlInit_v2 function as declared in nvml/nvml.h func nvmlInit_v2() Return { - __ret := C.nvmlInit_v2() + __ret := C.dispatch_nvmlInit_v2() __v := (Return)(__ret) return __v } @@ -38,14 +37,14 @@ func nvmlInit_v2() Return { // nvmlInitWithFlags function as declared in nvml/nvml.h func nvmlInitWithFlags(Flags uint32) Return { cFlags, _ := (C.uint)(Flags), cgoAllocsUnknown - __ret := C.nvmlInitWithFlags(cFlags) + __ret := C.dispatch_nvmlInitWithFlags(cFlags) __v := (Return)(__ret) return __v } // nvmlShutdown function as declared in nvml/nvml.h func nvmlShutdown() Return { - __ret := C.nvmlShutdown() + __ret := C.dispatch_nvmlShutdown() __v := (Return)(__ret) return __v } @@ -53,7 +52,7 @@ func nvmlShutdown() Return { // nvmlErrorString function as declared in nvml/nvml.h func nvmlErrorString(Result Return) string { cResult, _ := (C.nvmlReturn_t)(Result), cgoAllocsUnknown - __ret := C.nvmlErrorString(cResult) + __ret := C.dispatch_nvmlErrorString(cResult) __v := packPCharString(__ret) return __v } @@ -62,7 +61,7 @@ func nvmlErrorString(Result Return) string { func nvmlSystemGetDriverVersion(Version *byte, Length uint32) Return { cVersion, _ := (*C.char)(unsafe.Pointer(Version)), cgoAllocsUnknown cLength, _ := (C.uint)(Length), cgoAllocsUnknown - __ret := C.nvmlSystemGetDriverVersion(cVersion, cLength) + __ret := C.dispatch_nvmlSystemGetDriverVersion(cVersion, cLength) __v := (Return)(__ret) return __v } @@ -71,7 +70,7 @@ func nvmlSystemGetDriverVersion(Version *byte, Length uint32) Return { func nvmlSystemGetNVMLVersion(Version *byte, Length uint32) Return { cVersion, _ := (*C.char)(unsafe.Pointer(Version)), cgoAllocsUnknown cLength, _ := (C.uint)(Length), cgoAllocsUnknown - __ret := C.nvmlSystemGetNVMLVersion(cVersion, cLength) + __ret := C.dispatch_nvmlSystemGetNVMLVersion(cVersion, cLength) __v := (Return)(__ret) return __v } @@ -79,7 +78,7 @@ func nvmlSystemGetNVMLVersion(Version *byte, Length uint32) Return { // nvmlSystemGetCudaDriverVersion function as declared in nvml/nvml.h func nvmlSystemGetCudaDriverVersion(CudaDriverVersion *int32) Return { cCudaDriverVersion, _ := (*C.int)(unsafe.Pointer(CudaDriverVersion)), cgoAllocsUnknown - __ret := C.nvmlSystemGetCudaDriverVersion(cCudaDriverVersion) + __ret := C.dispatch_nvmlSystemGetCudaDriverVersion(cCudaDriverVersion) __v := (Return)(__ret) return __v } @@ -87,7 +86,7 @@ func nvmlSystemGetCudaDriverVersion(CudaDriverVersion *int32) Return { // nvmlSystemGetCudaDriverVersion_v2 function as declared in nvml/nvml.h func nvmlSystemGetCudaDriverVersion_v2(CudaDriverVersion *int32) Return { cCudaDriverVersion, _ := (*C.int)(unsafe.Pointer(CudaDriverVersion)), cgoAllocsUnknown - __ret := C.nvmlSystemGetCudaDriverVersion_v2(cCudaDriverVersion) + __ret := C.dispatch_nvmlSystemGetCudaDriverVersion_v2(cCudaDriverVersion) __v := (Return)(__ret) return __v } @@ -97,7 +96,7 @@ func nvmlSystemGetProcessName(Pid uint32, Name *byte, Length uint32) Return { cPid, _ := (C.uint)(Pid), cgoAllocsUnknown cName, _ := (*C.char)(unsafe.Pointer(Name)), cgoAllocsUnknown cLength, _ := (C.uint)(Length), cgoAllocsUnknown - __ret := C.nvmlSystemGetProcessName(cPid, cName, cLength) + __ret := C.dispatch_nvmlSystemGetProcessName(cPid, cName, cLength) __v := (Return)(__ret) return __v } @@ -106,7 +105,7 @@ func nvmlSystemGetProcessName(Pid uint32, Name *byte, Length uint32) Return { func nvmlSystemGetHicVersion(HwbcCount *uint32, HwbcEntries *HwbcEntry) Return { cHwbcCount, _ := (*C.uint)(unsafe.Pointer(HwbcCount)), cgoAllocsUnknown cHwbcEntries, _ := (*C.nvmlHwbcEntry_t)(unsafe.Pointer(HwbcEntries)), cgoAllocsUnknown - __ret := C.nvmlSystemGetHicVersion(cHwbcCount, cHwbcEntries) + __ret := C.dispatch_nvmlSystemGetHicVersion(cHwbcCount, cHwbcEntries) __v := (Return)(__ret) return __v } @@ -116,7 +115,7 @@ func nvmlSystemGetTopologyGpuSet(CpuNumber uint32, Count *uint32, DeviceArray *n cCpuNumber, _ := (C.uint)(CpuNumber), cgoAllocsUnknown cCount, _ := (*C.uint)(unsafe.Pointer(Count)), cgoAllocsUnknown cDeviceArray, _ := (*C.nvmlDevice_t)(unsafe.Pointer(DeviceArray)), cgoAllocsUnknown - __ret := C.nvmlSystemGetTopologyGpuSet(cCpuNumber, cCount, cDeviceArray) + __ret := C.dispatch_nvmlSystemGetTopologyGpuSet(cCpuNumber, cCount, cDeviceArray) __v := (Return)(__ret) return __v } @@ -125,7 +124,7 @@ func nvmlSystemGetTopologyGpuSet(CpuNumber uint32, Count *uint32, DeviceArray *n func nvmlSystemGetDriverBranch(BranchInfo *SystemDriverBranchInfo, Length uint32) Return { cBranchInfo, _ := (*C.nvmlSystemDriverBranchInfo_t)(unsafe.Pointer(BranchInfo)), cgoAllocsUnknown cLength, _ := (C.uint)(Length), cgoAllocsUnknown - __ret := C.nvmlSystemGetDriverBranch(cBranchInfo, cLength) + __ret := C.dispatch_nvmlSystemGetDriverBranch(cBranchInfo, cLength) __v := (Return)(__ret) return __v } @@ -133,7 +132,7 @@ func nvmlSystemGetDriverBranch(BranchInfo *SystemDriverBranchInfo, Length uint32 // nvmlUnitGetCount function as declared in nvml/nvml.h func nvmlUnitGetCount(UnitCount *uint32) Return { cUnitCount, _ := (*C.uint)(unsafe.Pointer(UnitCount)), cgoAllocsUnknown - __ret := C.nvmlUnitGetCount(cUnitCount) + __ret := C.dispatch_nvmlUnitGetCount(cUnitCount) __v := (Return)(__ret) return __v } @@ -142,7 +141,7 @@ func nvmlUnitGetCount(UnitCount *uint32) Return { func nvmlUnitGetHandleByIndex(Index uint32, nvmlUnit *nvmlUnit) Return { cIndex, _ := (C.uint)(Index), cgoAllocsUnknown cnvmlUnit, _ := (*C.nvmlUnit_t)(unsafe.Pointer(nvmlUnit)), cgoAllocsUnknown - __ret := C.nvmlUnitGetHandleByIndex(cIndex, cnvmlUnit) + __ret := C.dispatch_nvmlUnitGetHandleByIndex(cIndex, cnvmlUnit) __v := (Return)(__ret) return __v } @@ -151,7 +150,7 @@ func nvmlUnitGetHandleByIndex(Index uint32, nvmlUnit *nvmlUnit) Return { func nvmlUnitGetUnitInfo(nvmlUnit nvmlUnit, Info *UnitInfo) Return { cnvmlUnit, _ := *(*C.nvmlUnit_t)(unsafe.Pointer(&nvmlUnit)), cgoAllocsUnknown cInfo, _ := (*C.nvmlUnitInfo_t)(unsafe.Pointer(Info)), cgoAllocsUnknown - __ret := C.nvmlUnitGetUnitInfo(cnvmlUnit, cInfo) + __ret := C.dispatch_nvmlUnitGetUnitInfo(cnvmlUnit, cInfo) __v := (Return)(__ret) return __v } @@ -160,7 +159,7 @@ func nvmlUnitGetUnitInfo(nvmlUnit nvmlUnit, Info *UnitInfo) Return { func nvmlUnitGetLedState(nvmlUnit nvmlUnit, State *LedState) Return { cnvmlUnit, _ := *(*C.nvmlUnit_t)(unsafe.Pointer(&nvmlUnit)), cgoAllocsUnknown cState, _ := (*C.nvmlLedState_t)(unsafe.Pointer(State)), cgoAllocsUnknown - __ret := C.nvmlUnitGetLedState(cnvmlUnit, cState) + __ret := C.dispatch_nvmlUnitGetLedState(cnvmlUnit, cState) __v := (Return)(__ret) return __v } @@ -169,7 +168,7 @@ func nvmlUnitGetLedState(nvmlUnit nvmlUnit, State *LedState) Return { func nvmlUnitGetPsuInfo(nvmlUnit nvmlUnit, Psu *PSUInfo) Return { cnvmlUnit, _ := *(*C.nvmlUnit_t)(unsafe.Pointer(&nvmlUnit)), cgoAllocsUnknown cPsu, _ := (*C.nvmlPSUInfo_t)(unsafe.Pointer(Psu)), cgoAllocsUnknown - __ret := C.nvmlUnitGetPsuInfo(cnvmlUnit, cPsu) + __ret := C.dispatch_nvmlUnitGetPsuInfo(cnvmlUnit, cPsu) __v := (Return)(__ret) return __v } @@ -179,7 +178,7 @@ func nvmlUnitGetTemperature(nvmlUnit nvmlUnit, _type uint32, Temp *uint32) Retur cnvmlUnit, _ := *(*C.nvmlUnit_t)(unsafe.Pointer(&nvmlUnit)), cgoAllocsUnknown c_type, _ := (C.uint)(_type), cgoAllocsUnknown cTemp, _ := (*C.uint)(unsafe.Pointer(Temp)), cgoAllocsUnknown - __ret := C.nvmlUnitGetTemperature(cnvmlUnit, c_type, cTemp) + __ret := C.dispatch_nvmlUnitGetTemperature(cnvmlUnit, c_type, cTemp) __v := (Return)(__ret) return __v } @@ -188,7 +187,7 @@ func nvmlUnitGetTemperature(nvmlUnit nvmlUnit, _type uint32, Temp *uint32) Retur func nvmlUnitGetFanSpeedInfo(nvmlUnit nvmlUnit, FanSpeeds *UnitFanSpeeds) Return { cnvmlUnit, _ := *(*C.nvmlUnit_t)(unsafe.Pointer(&nvmlUnit)), cgoAllocsUnknown cFanSpeeds, _ := (*C.nvmlUnitFanSpeeds_t)(unsafe.Pointer(FanSpeeds)), cgoAllocsUnknown - __ret := C.nvmlUnitGetFanSpeedInfo(cnvmlUnit, cFanSpeeds) + __ret := C.dispatch_nvmlUnitGetFanSpeedInfo(cnvmlUnit, cFanSpeeds) __v := (Return)(__ret) return __v } @@ -198,7 +197,7 @@ func nvmlUnitGetDevices(nvmlUnit nvmlUnit, DeviceCount *uint32, Devices *nvmlDev cnvmlUnit, _ := *(*C.nvmlUnit_t)(unsafe.Pointer(&nvmlUnit)), cgoAllocsUnknown cDeviceCount, _ := (*C.uint)(unsafe.Pointer(DeviceCount)), cgoAllocsUnknown cDevices, _ := (*C.nvmlDevice_t)(unsafe.Pointer(Devices)), cgoAllocsUnknown - __ret := C.nvmlUnitGetDevices(cnvmlUnit, cDeviceCount, cDevices) + __ret := C.dispatch_nvmlUnitGetDevices(cnvmlUnit, cDeviceCount, cDevices) __v := (Return)(__ret) return __v } @@ -206,7 +205,7 @@ func nvmlUnitGetDevices(nvmlUnit nvmlUnit, DeviceCount *uint32, Devices *nvmlDev // nvmlDeviceGetCount_v2 function as declared in nvml/nvml.h func nvmlDeviceGetCount_v2(DeviceCount *uint32) Return { cDeviceCount, _ := (*C.uint)(unsafe.Pointer(DeviceCount)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetCount_v2(cDeviceCount) + __ret := C.dispatch_nvmlDeviceGetCount_v2(cDeviceCount) __v := (Return)(__ret) return __v } @@ -215,7 +214,7 @@ func nvmlDeviceGetCount_v2(DeviceCount *uint32) Return { func nvmlDeviceGetAttributes_v2(nvmlDevice nvmlDevice, Attributes *DeviceAttributes) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cAttributes, _ := (*C.nvmlDeviceAttributes_t)(unsafe.Pointer(Attributes)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetAttributes_v2(cnvmlDevice, cAttributes) + __ret := C.dispatch_nvmlDeviceGetAttributes_v2(cnvmlDevice, cAttributes) __v := (Return)(__ret) return __v } @@ -224,7 +223,7 @@ func nvmlDeviceGetAttributes_v2(nvmlDevice nvmlDevice, Attributes *DeviceAttribu func nvmlDeviceGetHandleByIndex_v2(Index uint32, nvmlDevice *nvmlDevice) Return { cIndex, _ := (C.uint)(Index), cgoAllocsUnknown cnvmlDevice, _ := (*C.nvmlDevice_t)(unsafe.Pointer(nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetHandleByIndex_v2(cIndex, cnvmlDevice) + __ret := C.dispatch_nvmlDeviceGetHandleByIndex_v2(cIndex, cnvmlDevice) __v := (Return)(__ret) return __v } @@ -233,7 +232,7 @@ func nvmlDeviceGetHandleByIndex_v2(Index uint32, nvmlDevice *nvmlDevice) Return func nvmlDeviceGetHandleBySerial(Serial string, nvmlDevice *nvmlDevice) Return { cSerial, _ := unpackPCharString(Serial) cnvmlDevice, _ := (*C.nvmlDevice_t)(unsafe.Pointer(nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetHandleBySerial(cSerial, cnvmlDevice) + __ret := C.dispatch_nvmlDeviceGetHandleBySerial(cSerial, cnvmlDevice) __v := (Return)(__ret) return __v } @@ -242,7 +241,7 @@ func nvmlDeviceGetHandleBySerial(Serial string, nvmlDevice *nvmlDevice) Return { func nvmlDeviceGetHandleByUUID(Uuid string, nvmlDevice *nvmlDevice) Return { cUuid, _ := unpackPCharString(Uuid) cnvmlDevice, _ := (*C.nvmlDevice_t)(unsafe.Pointer(nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetHandleByUUID(cUuid, cnvmlDevice) + __ret := C.dispatch_nvmlDeviceGetHandleByUUID(cUuid, cnvmlDevice) __v := (Return)(__ret) return __v } @@ -251,7 +250,7 @@ func nvmlDeviceGetHandleByUUID(Uuid string, nvmlDevice *nvmlDevice) Return { func nvmlDeviceGetHandleByUUIDV(Uuid *UUID, nvmlDevice *nvmlDevice) Return { cUuid, _ := (*C.nvmlUUID_t)(unsafe.Pointer(Uuid)), cgoAllocsUnknown cnvmlDevice, _ := (*C.nvmlDevice_t)(unsafe.Pointer(nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetHandleByUUIDV(cUuid, cnvmlDevice) + __ret := C.dispatch_nvmlDeviceGetHandleByUUIDV(cUuid, cnvmlDevice) __v := (Return)(__ret) return __v } @@ -260,7 +259,7 @@ func nvmlDeviceGetHandleByUUIDV(Uuid *UUID, nvmlDevice *nvmlDevice) Return { func nvmlDeviceGetHandleByPciBusId_v2(PciBusId string, nvmlDevice *nvmlDevice) Return { cPciBusId, _ := unpackPCharString(PciBusId) cnvmlDevice, _ := (*C.nvmlDevice_t)(unsafe.Pointer(nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetHandleByPciBusId_v2(cPciBusId, cnvmlDevice) + __ret := C.dispatch_nvmlDeviceGetHandleByPciBusId_v2(cPciBusId, cnvmlDevice) __v := (Return)(__ret) return __v } @@ -270,7 +269,7 @@ func nvmlDeviceGetName(nvmlDevice nvmlDevice, Name *byte, Length uint32) Return cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cName, _ := (*C.char)(unsafe.Pointer(Name)), cgoAllocsUnknown cLength, _ := (C.uint)(Length), cgoAllocsUnknown - __ret := C.nvmlDeviceGetName(cnvmlDevice, cName, cLength) + __ret := C.dispatch_nvmlDeviceGetName(cnvmlDevice, cName, cLength) __v := (Return)(__ret) return __v } @@ -279,7 +278,7 @@ func nvmlDeviceGetName(nvmlDevice nvmlDevice, Name *byte, Length uint32) Return func nvmlDeviceGetBrand(nvmlDevice nvmlDevice, _type *BrandType) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown c_type, _ := (*C.nvmlBrandType_t)(unsafe.Pointer(_type)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetBrand(cnvmlDevice, c_type) + __ret := C.dispatch_nvmlDeviceGetBrand(cnvmlDevice, c_type) __v := (Return)(__ret) return __v } @@ -288,7 +287,7 @@ func nvmlDeviceGetBrand(nvmlDevice nvmlDevice, _type *BrandType) Return { func nvmlDeviceGetIndex(nvmlDevice nvmlDevice, Index *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cIndex, _ := (*C.uint)(unsafe.Pointer(Index)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetIndex(cnvmlDevice, cIndex) + __ret := C.dispatch_nvmlDeviceGetIndex(cnvmlDevice, cIndex) __v := (Return)(__ret) return __v } @@ -298,7 +297,7 @@ func nvmlDeviceGetSerial(nvmlDevice nvmlDevice, Serial *byte, Length uint32) Ret cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cSerial, _ := (*C.char)(unsafe.Pointer(Serial)), cgoAllocsUnknown cLength, _ := (C.uint)(Length), cgoAllocsUnknown - __ret := C.nvmlDeviceGetSerial(cnvmlDevice, cSerial, cLength) + __ret := C.dispatch_nvmlDeviceGetSerial(cnvmlDevice, cSerial, cLength) __v := (Return)(__ret) return __v } @@ -307,7 +306,7 @@ func nvmlDeviceGetSerial(nvmlDevice nvmlDevice, Serial *byte, Length uint32) Ret func nvmlDeviceGetModuleId(nvmlDevice nvmlDevice, ModuleId *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cModuleId, _ := (*C.uint)(unsafe.Pointer(ModuleId)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetModuleId(cnvmlDevice, cModuleId) + __ret := C.dispatch_nvmlDeviceGetModuleId(cnvmlDevice, cModuleId) __v := (Return)(__ret) return __v } @@ -316,7 +315,7 @@ func nvmlDeviceGetModuleId(nvmlDevice nvmlDevice, ModuleId *uint32) Return { func nvmlDeviceGetC2cModeInfoV(nvmlDevice nvmlDevice, C2cModeInfo *C2cModeInfo_v1) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cC2cModeInfo, _ := (*C.nvmlC2cModeInfo_v1_t)(unsafe.Pointer(C2cModeInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetC2cModeInfoV(cnvmlDevice, cC2cModeInfo) + __ret := C.dispatch_nvmlDeviceGetC2cModeInfoV(cnvmlDevice, cC2cModeInfo) __v := (Return)(__ret) return __v } @@ -327,7 +326,7 @@ func nvmlDeviceGetMemoryAffinity(nvmlDevice nvmlDevice, NodeSetSize uint32, Node cNodeSetSize, _ := (C.uint)(NodeSetSize), cgoAllocsUnknown cNodeSet, _ := (*C.ulong)(unsafe.Pointer(NodeSet)), cgoAllocsUnknown cScope, _ := (C.nvmlAffinityScope_t)(Scope), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMemoryAffinity(cnvmlDevice, cNodeSetSize, cNodeSet, cScope) + __ret := C.dispatch_nvmlDeviceGetMemoryAffinity(cnvmlDevice, cNodeSetSize, cNodeSet, cScope) __v := (Return)(__ret) return __v } @@ -338,7 +337,7 @@ func nvmlDeviceGetCpuAffinityWithinScope(nvmlDevice nvmlDevice, CpuSetSize uint3 cCpuSetSize, _ := (C.uint)(CpuSetSize), cgoAllocsUnknown cCpuSet, _ := (*C.ulong)(unsafe.Pointer(CpuSet)), cgoAllocsUnknown cScope, _ := (C.nvmlAffinityScope_t)(Scope), cgoAllocsUnknown - __ret := C.nvmlDeviceGetCpuAffinityWithinScope(cnvmlDevice, cCpuSetSize, cCpuSet, cScope) + __ret := C.dispatch_nvmlDeviceGetCpuAffinityWithinScope(cnvmlDevice, cCpuSetSize, cCpuSet, cScope) __v := (Return)(__ret) return __v } @@ -348,7 +347,7 @@ func nvmlDeviceGetCpuAffinity(nvmlDevice nvmlDevice, CpuSetSize uint32, CpuSet * cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCpuSetSize, _ := (C.uint)(CpuSetSize), cgoAllocsUnknown cCpuSet, _ := (*C.ulong)(unsafe.Pointer(CpuSet)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetCpuAffinity(cnvmlDevice, cCpuSetSize, cCpuSet) + __ret := C.dispatch_nvmlDeviceGetCpuAffinity(cnvmlDevice, cCpuSetSize, cCpuSet) __v := (Return)(__ret) return __v } @@ -356,7 +355,7 @@ func nvmlDeviceGetCpuAffinity(nvmlDevice nvmlDevice, CpuSetSize uint32, CpuSet * // nvmlDeviceSetCpuAffinity function as declared in nvml/nvml.h func nvmlDeviceSetCpuAffinity(nvmlDevice nvmlDevice) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceSetCpuAffinity(cnvmlDevice) + __ret := C.dispatch_nvmlDeviceSetCpuAffinity(cnvmlDevice) __v := (Return)(__ret) return __v } @@ -364,7 +363,7 @@ func nvmlDeviceSetCpuAffinity(nvmlDevice nvmlDevice) Return { // nvmlDeviceClearCpuAffinity function as declared in nvml/nvml.h func nvmlDeviceClearCpuAffinity(nvmlDevice nvmlDevice) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceClearCpuAffinity(cnvmlDevice) + __ret := C.dispatch_nvmlDeviceClearCpuAffinity(cnvmlDevice) __v := (Return)(__ret) return __v } @@ -373,7 +372,7 @@ func nvmlDeviceClearCpuAffinity(nvmlDevice nvmlDevice) Return { func nvmlDeviceGetNumaNodeId(nvmlDevice nvmlDevice, Node *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cNode, _ := (*C.uint)(unsafe.Pointer(Node)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNumaNodeId(cnvmlDevice, cNode) + __ret := C.dispatch_nvmlDeviceGetNumaNodeId(cnvmlDevice, cNode) __v := (Return)(__ret) return __v } @@ -382,7 +381,7 @@ func nvmlDeviceGetNumaNodeId(nvmlDevice nvmlDevice, Node *uint32) Return { func nvmlDeviceGetAddressingMode(nvmlDevice nvmlDevice, Mode *DeviceAddressingMode) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMode, _ := (*C.nvmlDeviceAddressingMode_t)(unsafe.Pointer(Mode)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetAddressingMode(cnvmlDevice, cMode) + __ret := C.dispatch_nvmlDeviceGetAddressingMode(cnvmlDevice, cMode) __v := (Return)(__ret) return __v } @@ -391,7 +390,7 @@ func nvmlDeviceGetAddressingMode(nvmlDevice nvmlDevice, Mode *DeviceAddressingMo func nvmlDeviceGetRepairStatus(nvmlDevice nvmlDevice, RepairStatus *RepairStatus) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cRepairStatus, _ := (*C.nvmlRepairStatus_t)(unsafe.Pointer(RepairStatus)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetRepairStatus(cnvmlDevice, cRepairStatus) + __ret := C.dispatch_nvmlDeviceGetRepairStatus(cnvmlDevice, cRepairStatus) __v := (Return)(__ret) return __v } @@ -401,7 +400,7 @@ func nvmlDeviceGetTopologyCommonAncestor(Device1 nvmlDevice, Device2 nvmlDevice, cDevice1, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&Device1)), cgoAllocsUnknown cDevice2, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&Device2)), cgoAllocsUnknown cPathInfo, _ := (*C.nvmlGpuTopologyLevel_t)(unsafe.Pointer(PathInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetTopologyCommonAncestor(cDevice1, cDevice2, cPathInfo) + __ret := C.dispatch_nvmlDeviceGetTopologyCommonAncestor(cDevice1, cDevice2, cPathInfo) __v := (Return)(__ret) return __v } @@ -412,7 +411,7 @@ func nvmlDeviceGetTopologyNearestGpus(nvmlDevice nvmlDevice, Level GpuTopologyLe cLevel, _ := (C.nvmlGpuTopologyLevel_t)(Level), cgoAllocsUnknown cCount, _ := (*C.uint)(unsafe.Pointer(Count)), cgoAllocsUnknown cDeviceArray, _ := (*C.nvmlDevice_t)(unsafe.Pointer(DeviceArray)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetTopologyNearestGpus(cnvmlDevice, cLevel, cCount, cDeviceArray) + __ret := C.dispatch_nvmlDeviceGetTopologyNearestGpus(cnvmlDevice, cLevel, cCount, cDeviceArray) __v := (Return)(__ret) return __v } @@ -423,7 +422,7 @@ func nvmlDeviceGetP2PStatus(Device1 nvmlDevice, Device2 nvmlDevice, P2pIndex Gpu cDevice2, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&Device2)), cgoAllocsUnknown cP2pIndex, _ := (C.nvmlGpuP2PCapsIndex_t)(P2pIndex), cgoAllocsUnknown cP2pStatus, _ := (*C.nvmlGpuP2PStatus_t)(unsafe.Pointer(P2pStatus)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetP2PStatus(cDevice1, cDevice2, cP2pIndex, cP2pStatus) + __ret := C.dispatch_nvmlDeviceGetP2PStatus(cDevice1, cDevice2, cP2pIndex, cP2pStatus) __v := (Return)(__ret) return __v } @@ -433,7 +432,7 @@ func nvmlDeviceGetUUID(nvmlDevice nvmlDevice, Uuid *byte, Length uint32) Return cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cUuid, _ := (*C.char)(unsafe.Pointer(Uuid)), cgoAllocsUnknown cLength, _ := (C.uint)(Length), cgoAllocsUnknown - __ret := C.nvmlDeviceGetUUID(cnvmlDevice, cUuid, cLength) + __ret := C.dispatch_nvmlDeviceGetUUID(cnvmlDevice, cUuid, cLength) __v := (Return)(__ret) return __v } @@ -442,7 +441,7 @@ func nvmlDeviceGetUUID(nvmlDevice nvmlDevice, Uuid *byte, Length uint32) Return func nvmlDeviceGetMinorNumber(nvmlDevice nvmlDevice, MinorNumber *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMinorNumber, _ := (*C.uint)(unsafe.Pointer(MinorNumber)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMinorNumber(cnvmlDevice, cMinorNumber) + __ret := C.dispatch_nvmlDeviceGetMinorNumber(cnvmlDevice, cMinorNumber) __v := (Return)(__ret) return __v } @@ -452,7 +451,7 @@ func nvmlDeviceGetBoardPartNumber(nvmlDevice nvmlDevice, PartNumber *byte, Lengt cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPartNumber, _ := (*C.char)(unsafe.Pointer(PartNumber)), cgoAllocsUnknown cLength, _ := (C.uint)(Length), cgoAllocsUnknown - __ret := C.nvmlDeviceGetBoardPartNumber(cnvmlDevice, cPartNumber, cLength) + __ret := C.dispatch_nvmlDeviceGetBoardPartNumber(cnvmlDevice, cPartNumber, cLength) __v := (Return)(__ret) return __v } @@ -463,7 +462,7 @@ func nvmlDeviceGetInforomVersion(nvmlDevice nvmlDevice, Object InforomObject, Ve cObject, _ := (C.nvmlInforomObject_t)(Object), cgoAllocsUnknown cVersion, _ := (*C.char)(unsafe.Pointer(Version)), cgoAllocsUnknown cLength, _ := (C.uint)(Length), cgoAllocsUnknown - __ret := C.nvmlDeviceGetInforomVersion(cnvmlDevice, cObject, cVersion, cLength) + __ret := C.dispatch_nvmlDeviceGetInforomVersion(cnvmlDevice, cObject, cVersion, cLength) __v := (Return)(__ret) return __v } @@ -473,7 +472,7 @@ func nvmlDeviceGetInforomImageVersion(nvmlDevice nvmlDevice, Version *byte, Leng cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cVersion, _ := (*C.char)(unsafe.Pointer(Version)), cgoAllocsUnknown cLength, _ := (C.uint)(Length), cgoAllocsUnknown - __ret := C.nvmlDeviceGetInforomImageVersion(cnvmlDevice, cVersion, cLength) + __ret := C.dispatch_nvmlDeviceGetInforomImageVersion(cnvmlDevice, cVersion, cLength) __v := (Return)(__ret) return __v } @@ -482,7 +481,7 @@ func nvmlDeviceGetInforomImageVersion(nvmlDevice nvmlDevice, Version *byte, Leng func nvmlDeviceGetInforomConfigurationChecksum(nvmlDevice nvmlDevice, Checksum *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cChecksum, _ := (*C.uint)(unsafe.Pointer(Checksum)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetInforomConfigurationChecksum(cnvmlDevice, cChecksum) + __ret := C.dispatch_nvmlDeviceGetInforomConfigurationChecksum(cnvmlDevice, cChecksum) __v := (Return)(__ret) return __v } @@ -490,7 +489,7 @@ func nvmlDeviceGetInforomConfigurationChecksum(nvmlDevice nvmlDevice, Checksum * // nvmlDeviceValidateInforom function as declared in nvml/nvml.h func nvmlDeviceValidateInforom(nvmlDevice nvmlDevice) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceValidateInforom(cnvmlDevice) + __ret := C.dispatch_nvmlDeviceValidateInforom(cnvmlDevice) __v := (Return)(__ret) return __v } @@ -500,7 +499,7 @@ func nvmlDeviceGetLastBBXFlushTime(nvmlDevice nvmlDevice, Timestamp *uint64, Dur cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cTimestamp, _ := (*C.ulonglong)(unsafe.Pointer(Timestamp)), cgoAllocsUnknown cDurationUs, _ := (*C.ulong)(unsafe.Pointer(DurationUs)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetLastBBXFlushTime(cnvmlDevice, cTimestamp, cDurationUs) + __ret := C.dispatch_nvmlDeviceGetLastBBXFlushTime(cnvmlDevice, cTimestamp, cDurationUs) __v := (Return)(__ret) return __v } @@ -509,7 +508,7 @@ func nvmlDeviceGetLastBBXFlushTime(nvmlDevice nvmlDevice, Timestamp *uint64, Dur func nvmlDeviceGetDisplayMode(nvmlDevice nvmlDevice, Display *EnableState) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cDisplay, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(Display)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetDisplayMode(cnvmlDevice, cDisplay) + __ret := C.dispatch_nvmlDeviceGetDisplayMode(cnvmlDevice, cDisplay) __v := (Return)(__ret) return __v } @@ -518,7 +517,7 @@ func nvmlDeviceGetDisplayMode(nvmlDevice nvmlDevice, Display *EnableState) Retur func nvmlDeviceGetDisplayActive(nvmlDevice nvmlDevice, IsActive *EnableState) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cIsActive, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(IsActive)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetDisplayActive(cnvmlDevice, cIsActive) + __ret := C.dispatch_nvmlDeviceGetDisplayActive(cnvmlDevice, cIsActive) __v := (Return)(__ret) return __v } @@ -527,7 +526,7 @@ func nvmlDeviceGetDisplayActive(nvmlDevice nvmlDevice, IsActive *EnableState) Re func nvmlDeviceGetPersistenceMode(nvmlDevice nvmlDevice, Mode *EnableState) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMode, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(Mode)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPersistenceMode(cnvmlDevice, cMode) + __ret := C.dispatch_nvmlDeviceGetPersistenceMode(cnvmlDevice, cMode) __v := (Return)(__ret) return __v } @@ -536,7 +535,7 @@ func nvmlDeviceGetPersistenceMode(nvmlDevice nvmlDevice, Mode *EnableState) Retu func nvmlDeviceGetPciInfoExt(nvmlDevice nvmlDevice, Pci *PciInfoExt) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPci, _ := (*C.nvmlPciInfoExt_t)(unsafe.Pointer(Pci)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPciInfoExt(cnvmlDevice, cPci) + __ret := C.dispatch_nvmlDeviceGetPciInfoExt(cnvmlDevice, cPci) __v := (Return)(__ret) return __v } @@ -545,7 +544,7 @@ func nvmlDeviceGetPciInfoExt(nvmlDevice nvmlDevice, Pci *PciInfoExt) Return { func nvmlDeviceGetPciInfo_v3(nvmlDevice nvmlDevice, Pci *PciInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPci, _ := (*C.nvmlPciInfo_t)(unsafe.Pointer(Pci)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPciInfo_v3(cnvmlDevice, cPci) + __ret := C.dispatch_nvmlDeviceGetPciInfo_v3(cnvmlDevice, cPci) __v := (Return)(__ret) return __v } @@ -554,7 +553,7 @@ func nvmlDeviceGetPciInfo_v3(nvmlDevice nvmlDevice, Pci *PciInfo) Return { func nvmlDeviceGetMaxPcieLinkGeneration(nvmlDevice nvmlDevice, MaxLinkGen *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMaxLinkGen, _ := (*C.uint)(unsafe.Pointer(MaxLinkGen)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMaxPcieLinkGeneration(cnvmlDevice, cMaxLinkGen) + __ret := C.dispatch_nvmlDeviceGetMaxPcieLinkGeneration(cnvmlDevice, cMaxLinkGen) __v := (Return)(__ret) return __v } @@ -563,7 +562,7 @@ func nvmlDeviceGetMaxPcieLinkGeneration(nvmlDevice nvmlDevice, MaxLinkGen *uint3 func nvmlDeviceGetGpuMaxPcieLinkGeneration(nvmlDevice nvmlDevice, MaxLinkGenDevice *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMaxLinkGenDevice, _ := (*C.uint)(unsafe.Pointer(MaxLinkGenDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpuMaxPcieLinkGeneration(cnvmlDevice, cMaxLinkGenDevice) + __ret := C.dispatch_nvmlDeviceGetGpuMaxPcieLinkGeneration(cnvmlDevice, cMaxLinkGenDevice) __v := (Return)(__ret) return __v } @@ -572,7 +571,7 @@ func nvmlDeviceGetGpuMaxPcieLinkGeneration(nvmlDevice nvmlDevice, MaxLinkGenDevi func nvmlDeviceGetMaxPcieLinkWidth(nvmlDevice nvmlDevice, MaxLinkWidth *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMaxLinkWidth, _ := (*C.uint)(unsafe.Pointer(MaxLinkWidth)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMaxPcieLinkWidth(cnvmlDevice, cMaxLinkWidth) + __ret := C.dispatch_nvmlDeviceGetMaxPcieLinkWidth(cnvmlDevice, cMaxLinkWidth) __v := (Return)(__ret) return __v } @@ -581,7 +580,7 @@ func nvmlDeviceGetMaxPcieLinkWidth(nvmlDevice nvmlDevice, MaxLinkWidth *uint32) func nvmlDeviceGetCurrPcieLinkGeneration(nvmlDevice nvmlDevice, CurrLinkGen *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCurrLinkGen, _ := (*C.uint)(unsafe.Pointer(CurrLinkGen)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetCurrPcieLinkGeneration(cnvmlDevice, cCurrLinkGen) + __ret := C.dispatch_nvmlDeviceGetCurrPcieLinkGeneration(cnvmlDevice, cCurrLinkGen) __v := (Return)(__ret) return __v } @@ -590,7 +589,7 @@ func nvmlDeviceGetCurrPcieLinkGeneration(nvmlDevice nvmlDevice, CurrLinkGen *uin func nvmlDeviceGetCurrPcieLinkWidth(nvmlDevice nvmlDevice, CurrLinkWidth *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCurrLinkWidth, _ := (*C.uint)(unsafe.Pointer(CurrLinkWidth)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetCurrPcieLinkWidth(cnvmlDevice, cCurrLinkWidth) + __ret := C.dispatch_nvmlDeviceGetCurrPcieLinkWidth(cnvmlDevice, cCurrLinkWidth) __v := (Return)(__ret) return __v } @@ -600,7 +599,7 @@ func nvmlDeviceGetPcieThroughput(nvmlDevice nvmlDevice, Counter PcieUtilCounter, cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCounter, _ := (C.nvmlPcieUtilCounter_t)(Counter), cgoAllocsUnknown cValue, _ := (*C.uint)(unsafe.Pointer(Value)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPcieThroughput(cnvmlDevice, cCounter, cValue) + __ret := C.dispatch_nvmlDeviceGetPcieThroughput(cnvmlDevice, cCounter, cValue) __v := (Return)(__ret) return __v } @@ -609,7 +608,7 @@ func nvmlDeviceGetPcieThroughput(nvmlDevice nvmlDevice, Counter PcieUtilCounter, func nvmlDeviceGetPcieReplayCounter(nvmlDevice nvmlDevice, Value *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cValue, _ := (*C.uint)(unsafe.Pointer(Value)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPcieReplayCounter(cnvmlDevice, cValue) + __ret := C.dispatch_nvmlDeviceGetPcieReplayCounter(cnvmlDevice, cValue) __v := (Return)(__ret) return __v } @@ -619,7 +618,7 @@ func nvmlDeviceGetClockInfo(nvmlDevice nvmlDevice, _type ClockType, Clock *uint3 cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown c_type, _ := (C.nvmlClockType_t)(_type), cgoAllocsUnknown cClock, _ := (*C.uint)(unsafe.Pointer(Clock)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetClockInfo(cnvmlDevice, c_type, cClock) + __ret := C.dispatch_nvmlDeviceGetClockInfo(cnvmlDevice, c_type, cClock) __v := (Return)(__ret) return __v } @@ -629,7 +628,7 @@ func nvmlDeviceGetMaxClockInfo(nvmlDevice nvmlDevice, _type ClockType, Clock *ui cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown c_type, _ := (C.nvmlClockType_t)(_type), cgoAllocsUnknown cClock, _ := (*C.uint)(unsafe.Pointer(Clock)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMaxClockInfo(cnvmlDevice, c_type, cClock) + __ret := C.dispatch_nvmlDeviceGetMaxClockInfo(cnvmlDevice, c_type, cClock) __v := (Return)(__ret) return __v } @@ -638,7 +637,7 @@ func nvmlDeviceGetMaxClockInfo(nvmlDevice nvmlDevice, _type ClockType, Clock *ui func nvmlDeviceGetGpcClkVfOffset(nvmlDevice nvmlDevice, Offset *int32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cOffset, _ := (*C.int)(unsafe.Pointer(Offset)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpcClkVfOffset(cnvmlDevice, cOffset) + __ret := C.dispatch_nvmlDeviceGetGpcClkVfOffset(cnvmlDevice, cOffset) __v := (Return)(__ret) return __v } @@ -648,7 +647,7 @@ func nvmlDeviceGetApplicationsClock(nvmlDevice nvmlDevice, ClockType ClockType, cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cClockType, _ := (C.nvmlClockType_t)(ClockType), cgoAllocsUnknown cClockMHz, _ := (*C.uint)(unsafe.Pointer(ClockMHz)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetApplicationsClock(cnvmlDevice, cClockType, cClockMHz) + __ret := C.dispatch_nvmlDeviceGetApplicationsClock(cnvmlDevice, cClockType, cClockMHz) __v := (Return)(__ret) return __v } @@ -658,7 +657,7 @@ func nvmlDeviceGetDefaultApplicationsClock(nvmlDevice nvmlDevice, ClockType Cloc cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cClockType, _ := (C.nvmlClockType_t)(ClockType), cgoAllocsUnknown cClockMHz, _ := (*C.uint)(unsafe.Pointer(ClockMHz)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetDefaultApplicationsClock(cnvmlDevice, cClockType, cClockMHz) + __ret := C.dispatch_nvmlDeviceGetDefaultApplicationsClock(cnvmlDevice, cClockType, cClockMHz) __v := (Return)(__ret) return __v } @@ -669,7 +668,7 @@ func nvmlDeviceGetClock(nvmlDevice nvmlDevice, ClockType ClockType, ClockId Cloc cClockType, _ := (C.nvmlClockType_t)(ClockType), cgoAllocsUnknown cClockId, _ := (C.nvmlClockId_t)(ClockId), cgoAllocsUnknown cClockMHz, _ := (*C.uint)(unsafe.Pointer(ClockMHz)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetClock(cnvmlDevice, cClockType, cClockId, cClockMHz) + __ret := C.dispatch_nvmlDeviceGetClock(cnvmlDevice, cClockType, cClockId, cClockMHz) __v := (Return)(__ret) return __v } @@ -679,7 +678,7 @@ func nvmlDeviceGetMaxCustomerBoostClock(nvmlDevice nvmlDevice, ClockType ClockTy cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cClockType, _ := (C.nvmlClockType_t)(ClockType), cgoAllocsUnknown cClockMHz, _ := (*C.uint)(unsafe.Pointer(ClockMHz)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMaxCustomerBoostClock(cnvmlDevice, cClockType, cClockMHz) + __ret := C.dispatch_nvmlDeviceGetMaxCustomerBoostClock(cnvmlDevice, cClockType, cClockMHz) __v := (Return)(__ret) return __v } @@ -689,7 +688,7 @@ func nvmlDeviceGetSupportedMemoryClocks(nvmlDevice nvmlDevice, Count *uint32, Cl cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCount, _ := (*C.uint)(unsafe.Pointer(Count)), cgoAllocsUnknown cClocksMHz, _ := (*C.uint)(unsafe.Pointer(ClocksMHz)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetSupportedMemoryClocks(cnvmlDevice, cCount, cClocksMHz) + __ret := C.dispatch_nvmlDeviceGetSupportedMemoryClocks(cnvmlDevice, cCount, cClocksMHz) __v := (Return)(__ret) return __v } @@ -700,7 +699,7 @@ func nvmlDeviceGetSupportedGraphicsClocks(nvmlDevice nvmlDevice, MemoryClockMHz cMemoryClockMHz, _ := (C.uint)(MemoryClockMHz), cgoAllocsUnknown cCount, _ := (*C.uint)(unsafe.Pointer(Count)), cgoAllocsUnknown cClocksMHz, _ := (*C.uint)(unsafe.Pointer(ClocksMHz)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetSupportedGraphicsClocks(cnvmlDevice, cMemoryClockMHz, cCount, cClocksMHz) + __ret := C.dispatch_nvmlDeviceGetSupportedGraphicsClocks(cnvmlDevice, cMemoryClockMHz, cCount, cClocksMHz) __v := (Return)(__ret) return __v } @@ -710,7 +709,7 @@ func nvmlDeviceGetAutoBoostedClocksEnabled(nvmlDevice nvmlDevice, IsEnabled *Ena cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cIsEnabled, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(IsEnabled)), cgoAllocsUnknown cDefaultIsEnabled, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(DefaultIsEnabled)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetAutoBoostedClocksEnabled(cnvmlDevice, cIsEnabled, cDefaultIsEnabled) + __ret := C.dispatch_nvmlDeviceGetAutoBoostedClocksEnabled(cnvmlDevice, cIsEnabled, cDefaultIsEnabled) __v := (Return)(__ret) return __v } @@ -719,7 +718,7 @@ func nvmlDeviceGetAutoBoostedClocksEnabled(nvmlDevice nvmlDevice, IsEnabled *Ena func nvmlDeviceGetFanSpeed(nvmlDevice nvmlDevice, Speed *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cSpeed, _ := (*C.uint)(unsafe.Pointer(Speed)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetFanSpeed(cnvmlDevice, cSpeed) + __ret := C.dispatch_nvmlDeviceGetFanSpeed(cnvmlDevice, cSpeed) __v := (Return)(__ret) return __v } @@ -729,7 +728,7 @@ func nvmlDeviceGetFanSpeed_v2(nvmlDevice nvmlDevice, Fan uint32, Speed *uint32) cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cFan, _ := (C.uint)(Fan), cgoAllocsUnknown cSpeed, _ := (*C.uint)(unsafe.Pointer(Speed)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetFanSpeed_v2(cnvmlDevice, cFan, cSpeed) + __ret := C.dispatch_nvmlDeviceGetFanSpeed_v2(cnvmlDevice, cFan, cSpeed) __v := (Return)(__ret) return __v } @@ -738,7 +737,7 @@ func nvmlDeviceGetFanSpeed_v2(nvmlDevice nvmlDevice, Fan uint32, Speed *uint32) func nvmlDeviceGetFanSpeedRPM(nvmlDevice nvmlDevice, FanSpeed *FanSpeedInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cFanSpeed, _ := (*C.nvmlFanSpeedInfo_t)(unsafe.Pointer(FanSpeed)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetFanSpeedRPM(cnvmlDevice, cFanSpeed) + __ret := C.dispatch_nvmlDeviceGetFanSpeedRPM(cnvmlDevice, cFanSpeed) __v := (Return)(__ret) return __v } @@ -748,7 +747,7 @@ func nvmlDeviceGetTargetFanSpeed(nvmlDevice nvmlDevice, Fan uint32, TargetSpeed cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cFan, _ := (C.uint)(Fan), cgoAllocsUnknown cTargetSpeed, _ := (*C.uint)(unsafe.Pointer(TargetSpeed)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetTargetFanSpeed(cnvmlDevice, cFan, cTargetSpeed) + __ret := C.dispatch_nvmlDeviceGetTargetFanSpeed(cnvmlDevice, cFan, cTargetSpeed) __v := (Return)(__ret) return __v } @@ -758,7 +757,7 @@ func nvmlDeviceGetMinMaxFanSpeed(nvmlDevice nvmlDevice, MinSpeed *uint32, MaxSpe cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMinSpeed, _ := (*C.uint)(unsafe.Pointer(MinSpeed)), cgoAllocsUnknown cMaxSpeed, _ := (*C.uint)(unsafe.Pointer(MaxSpeed)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMinMaxFanSpeed(cnvmlDevice, cMinSpeed, cMaxSpeed) + __ret := C.dispatch_nvmlDeviceGetMinMaxFanSpeed(cnvmlDevice, cMinSpeed, cMaxSpeed) __v := (Return)(__ret) return __v } @@ -768,7 +767,7 @@ func nvmlDeviceGetFanControlPolicy_v2(nvmlDevice nvmlDevice, Fan uint32, Policy cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cFan, _ := (C.uint)(Fan), cgoAllocsUnknown cPolicy, _ := (*C.nvmlFanControlPolicy_t)(unsafe.Pointer(Policy)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetFanControlPolicy_v2(cnvmlDevice, cFan, cPolicy) + __ret := C.dispatch_nvmlDeviceGetFanControlPolicy_v2(cnvmlDevice, cFan, cPolicy) __v := (Return)(__ret) return __v } @@ -777,7 +776,7 @@ func nvmlDeviceGetFanControlPolicy_v2(nvmlDevice nvmlDevice, Fan uint32, Policy func nvmlDeviceGetNumFans(nvmlDevice nvmlDevice, NumFans *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cNumFans, _ := (*C.uint)(unsafe.Pointer(NumFans)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNumFans(cnvmlDevice, cNumFans) + __ret := C.dispatch_nvmlDeviceGetNumFans(cnvmlDevice, cNumFans) __v := (Return)(__ret) return __v } @@ -787,7 +786,7 @@ func nvmlDeviceGetTemperature(nvmlDevice nvmlDevice, SensorType TemperatureSenso cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cSensorType, _ := (C.nvmlTemperatureSensors_t)(SensorType), cgoAllocsUnknown cTemp, _ := (*C.uint)(unsafe.Pointer(Temp)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetTemperature(cnvmlDevice, cSensorType, cTemp) + __ret := C.dispatch_nvmlDeviceGetTemperature(cnvmlDevice, cSensorType, cTemp) __v := (Return)(__ret) return __v } @@ -796,7 +795,7 @@ func nvmlDeviceGetTemperature(nvmlDevice nvmlDevice, SensorType TemperatureSenso func nvmlDeviceGetCoolerInfo(nvmlDevice nvmlDevice, CoolerInfo *CoolerInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCoolerInfo, _ := (*C.nvmlCoolerInfo_t)(unsafe.Pointer(CoolerInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetCoolerInfo(cnvmlDevice, cCoolerInfo) + __ret := C.dispatch_nvmlDeviceGetCoolerInfo(cnvmlDevice, cCoolerInfo) __v := (Return)(__ret) return __v } @@ -805,7 +804,7 @@ func nvmlDeviceGetCoolerInfo(nvmlDevice nvmlDevice, CoolerInfo *CoolerInfo) Retu func nvmlDeviceGetTemperatureV(nvmlDevice nvmlDevice, Temperature *Temperature) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cTemperature, _ := (*C.nvmlTemperature_t)(unsafe.Pointer(Temperature)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetTemperatureV(cnvmlDevice, cTemperature) + __ret := C.dispatch_nvmlDeviceGetTemperatureV(cnvmlDevice, cTemperature) __v := (Return)(__ret) return __v } @@ -815,7 +814,7 @@ func nvmlDeviceGetTemperatureThreshold(nvmlDevice nvmlDevice, ThresholdType Temp cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cThresholdType, _ := (C.nvmlTemperatureThresholds_t)(ThresholdType), cgoAllocsUnknown cTemp, _ := (*C.uint)(unsafe.Pointer(Temp)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetTemperatureThreshold(cnvmlDevice, cThresholdType, cTemp) + __ret := C.dispatch_nvmlDeviceGetTemperatureThreshold(cnvmlDevice, cThresholdType, cTemp) __v := (Return)(__ret) return __v } @@ -824,7 +823,7 @@ func nvmlDeviceGetTemperatureThreshold(nvmlDevice nvmlDevice, ThresholdType Temp func nvmlDeviceGetMarginTemperature(nvmlDevice nvmlDevice, MarginTempInfo *MarginTemperature) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMarginTempInfo, _ := (*C.nvmlMarginTemperature_t)(unsafe.Pointer(MarginTempInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMarginTemperature(cnvmlDevice, cMarginTempInfo) + __ret := C.dispatch_nvmlDeviceGetMarginTemperature(cnvmlDevice, cMarginTempInfo) __v := (Return)(__ret) return __v } @@ -834,7 +833,7 @@ func nvmlDeviceGetThermalSettings(nvmlDevice nvmlDevice, SensorIndex uint32, PTh cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cSensorIndex, _ := (C.uint)(SensorIndex), cgoAllocsUnknown cPThermalSettings, _ := (*C.nvmlGpuThermalSettings_t)(unsafe.Pointer(PThermalSettings)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetThermalSettings(cnvmlDevice, cSensorIndex, cPThermalSettings) + __ret := C.dispatch_nvmlDeviceGetThermalSettings(cnvmlDevice, cSensorIndex, cPThermalSettings) __v := (Return)(__ret) return __v } @@ -843,7 +842,7 @@ func nvmlDeviceGetThermalSettings(nvmlDevice nvmlDevice, SensorIndex uint32, PTh func nvmlDeviceGetPerformanceState(nvmlDevice nvmlDevice, PState *Pstates) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPState, _ := (*C.nvmlPstates_t)(unsafe.Pointer(PState)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPerformanceState(cnvmlDevice, cPState) + __ret := C.dispatch_nvmlDeviceGetPerformanceState(cnvmlDevice, cPState) __v := (Return)(__ret) return __v } @@ -852,7 +851,7 @@ func nvmlDeviceGetPerformanceState(nvmlDevice nvmlDevice, PState *Pstates) Retur func nvmlDeviceGetCurrentClocksEventReasons(nvmlDevice nvmlDevice, ClocksEventReasons *uint64) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cClocksEventReasons, _ := (*C.ulonglong)(unsafe.Pointer(ClocksEventReasons)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetCurrentClocksEventReasons(cnvmlDevice, cClocksEventReasons) + __ret := C.dispatch_nvmlDeviceGetCurrentClocksEventReasons(cnvmlDevice, cClocksEventReasons) __v := (Return)(__ret) return __v } @@ -861,7 +860,7 @@ func nvmlDeviceGetCurrentClocksEventReasons(nvmlDevice nvmlDevice, ClocksEventRe func nvmlDeviceGetCurrentClocksThrottleReasons(nvmlDevice nvmlDevice, ClocksThrottleReasons *uint64) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cClocksThrottleReasons, _ := (*C.ulonglong)(unsafe.Pointer(ClocksThrottleReasons)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetCurrentClocksThrottleReasons(cnvmlDevice, cClocksThrottleReasons) + __ret := C.dispatch_nvmlDeviceGetCurrentClocksThrottleReasons(cnvmlDevice, cClocksThrottleReasons) __v := (Return)(__ret) return __v } @@ -870,7 +869,7 @@ func nvmlDeviceGetCurrentClocksThrottleReasons(nvmlDevice nvmlDevice, ClocksThro func nvmlDeviceGetSupportedClocksEventReasons(nvmlDevice nvmlDevice, SupportedClocksEventReasons *uint64) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cSupportedClocksEventReasons, _ := (*C.ulonglong)(unsafe.Pointer(SupportedClocksEventReasons)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetSupportedClocksEventReasons(cnvmlDevice, cSupportedClocksEventReasons) + __ret := C.dispatch_nvmlDeviceGetSupportedClocksEventReasons(cnvmlDevice, cSupportedClocksEventReasons) __v := (Return)(__ret) return __v } @@ -879,7 +878,7 @@ func nvmlDeviceGetSupportedClocksEventReasons(nvmlDevice nvmlDevice, SupportedCl func nvmlDeviceGetSupportedClocksThrottleReasons(nvmlDevice nvmlDevice, SupportedClocksThrottleReasons *uint64) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cSupportedClocksThrottleReasons, _ := (*C.ulonglong)(unsafe.Pointer(SupportedClocksThrottleReasons)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetSupportedClocksThrottleReasons(cnvmlDevice, cSupportedClocksThrottleReasons) + __ret := C.dispatch_nvmlDeviceGetSupportedClocksThrottleReasons(cnvmlDevice, cSupportedClocksThrottleReasons) __v := (Return)(__ret) return __v } @@ -888,7 +887,7 @@ func nvmlDeviceGetSupportedClocksThrottleReasons(nvmlDevice nvmlDevice, Supporte func nvmlDeviceGetPowerState(nvmlDevice nvmlDevice, PState *Pstates) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPState, _ := (*C.nvmlPstates_t)(unsafe.Pointer(PState)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPowerState(cnvmlDevice, cPState) + __ret := C.dispatch_nvmlDeviceGetPowerState(cnvmlDevice, cPState) __v := (Return)(__ret) return __v } @@ -897,7 +896,7 @@ func nvmlDeviceGetPowerState(nvmlDevice nvmlDevice, PState *Pstates) Return { func nvmlDeviceGetDynamicPstatesInfo(nvmlDevice nvmlDevice, PDynamicPstatesInfo *GpuDynamicPstatesInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPDynamicPstatesInfo, _ := (*C.nvmlGpuDynamicPstatesInfo_t)(unsafe.Pointer(PDynamicPstatesInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetDynamicPstatesInfo(cnvmlDevice, cPDynamicPstatesInfo) + __ret := C.dispatch_nvmlDeviceGetDynamicPstatesInfo(cnvmlDevice, cPDynamicPstatesInfo) __v := (Return)(__ret) return __v } @@ -906,7 +905,7 @@ func nvmlDeviceGetDynamicPstatesInfo(nvmlDevice nvmlDevice, PDynamicPstatesInfo func nvmlDeviceGetMemClkVfOffset(nvmlDevice nvmlDevice, Offset *int32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cOffset, _ := (*C.int)(unsafe.Pointer(Offset)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMemClkVfOffset(cnvmlDevice, cOffset) + __ret := C.dispatch_nvmlDeviceGetMemClkVfOffset(cnvmlDevice, cOffset) __v := (Return)(__ret) return __v } @@ -918,7 +917,7 @@ func nvmlDeviceGetMinMaxClockOfPState(nvmlDevice nvmlDevice, _type ClockType, Ps cPstate, _ := (C.nvmlPstates_t)(Pstate), cgoAllocsUnknown cMinClockMHz, _ := (*C.uint)(unsafe.Pointer(MinClockMHz)), cgoAllocsUnknown cMaxClockMHz, _ := (*C.uint)(unsafe.Pointer(MaxClockMHz)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMinMaxClockOfPState(cnvmlDevice, c_type, cPstate, cMinClockMHz, cMaxClockMHz) + __ret := C.dispatch_nvmlDeviceGetMinMaxClockOfPState(cnvmlDevice, c_type, cPstate, cMinClockMHz, cMaxClockMHz) __v := (Return)(__ret) return __v } @@ -928,7 +927,7 @@ func nvmlDeviceGetSupportedPerformanceStates(nvmlDevice nvmlDevice, Pstates *Pst cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPstates, _ := (*C.nvmlPstates_t)(unsafe.Pointer(Pstates)), cgoAllocsUnknown cSize, _ := (C.uint)(Size), cgoAllocsUnknown - __ret := C.nvmlDeviceGetSupportedPerformanceStates(cnvmlDevice, cPstates, cSize) + __ret := C.dispatch_nvmlDeviceGetSupportedPerformanceStates(cnvmlDevice, cPstates, cSize) __v := (Return)(__ret) return __v } @@ -938,7 +937,7 @@ func nvmlDeviceGetGpcClkMinMaxVfOffset(nvmlDevice nvmlDevice, MinOffset *int32, cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMinOffset, _ := (*C.int)(unsafe.Pointer(MinOffset)), cgoAllocsUnknown cMaxOffset, _ := (*C.int)(unsafe.Pointer(MaxOffset)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpcClkMinMaxVfOffset(cnvmlDevice, cMinOffset, cMaxOffset) + __ret := C.dispatch_nvmlDeviceGetGpcClkMinMaxVfOffset(cnvmlDevice, cMinOffset, cMaxOffset) __v := (Return)(__ret) return __v } @@ -948,7 +947,7 @@ func nvmlDeviceGetMemClkMinMaxVfOffset(nvmlDevice nvmlDevice, MinOffset *int32, cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMinOffset, _ := (*C.int)(unsafe.Pointer(MinOffset)), cgoAllocsUnknown cMaxOffset, _ := (*C.int)(unsafe.Pointer(MaxOffset)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMemClkMinMaxVfOffset(cnvmlDevice, cMinOffset, cMaxOffset) + __ret := C.dispatch_nvmlDeviceGetMemClkMinMaxVfOffset(cnvmlDevice, cMinOffset, cMaxOffset) __v := (Return)(__ret) return __v } @@ -957,7 +956,7 @@ func nvmlDeviceGetMemClkMinMaxVfOffset(nvmlDevice nvmlDevice, MinOffset *int32, func nvmlDeviceGetClockOffsets(nvmlDevice nvmlDevice, Info *ClockOffset) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cInfo, _ := (*C.nvmlClockOffset_t)(unsafe.Pointer(Info)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetClockOffsets(cnvmlDevice, cInfo) + __ret := C.dispatch_nvmlDeviceGetClockOffsets(cnvmlDevice, cInfo) __v := (Return)(__ret) return __v } @@ -966,7 +965,7 @@ func nvmlDeviceGetClockOffsets(nvmlDevice nvmlDevice, Info *ClockOffset) Return func nvmlDeviceSetClockOffsets(nvmlDevice nvmlDevice, Info *ClockOffset) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cInfo, _ := (*C.nvmlClockOffset_t)(unsafe.Pointer(Info)), cgoAllocsUnknown - __ret := C.nvmlDeviceSetClockOffsets(cnvmlDevice, cInfo) + __ret := C.dispatch_nvmlDeviceSetClockOffsets(cnvmlDevice, cInfo) __v := (Return)(__ret) return __v } @@ -975,7 +974,7 @@ func nvmlDeviceSetClockOffsets(nvmlDevice nvmlDevice, Info *ClockOffset) Return func nvmlDeviceGetPerformanceModes(nvmlDevice nvmlDevice, PerfModes *DevicePerfModes) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPerfModes, _ := (*C.nvmlDevicePerfModes_t)(unsafe.Pointer(PerfModes)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPerformanceModes(cnvmlDevice, cPerfModes) + __ret := C.dispatch_nvmlDeviceGetPerformanceModes(cnvmlDevice, cPerfModes) __v := (Return)(__ret) return __v } @@ -984,7 +983,7 @@ func nvmlDeviceGetPerformanceModes(nvmlDevice nvmlDevice, PerfModes *DevicePerfM func nvmlDeviceGetCurrentClockFreqs(nvmlDevice nvmlDevice, CurrentClockFreqs *DeviceCurrentClockFreqs) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCurrentClockFreqs, _ := (*C.nvmlDeviceCurrentClockFreqs_t)(unsafe.Pointer(CurrentClockFreqs)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetCurrentClockFreqs(cnvmlDevice, cCurrentClockFreqs) + __ret := C.dispatch_nvmlDeviceGetCurrentClockFreqs(cnvmlDevice, cCurrentClockFreqs) __v := (Return)(__ret) return __v } @@ -993,7 +992,7 @@ func nvmlDeviceGetCurrentClockFreqs(nvmlDevice nvmlDevice, CurrentClockFreqs *De func nvmlDeviceGetPowerManagementMode(nvmlDevice nvmlDevice, Mode *EnableState) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMode, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(Mode)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPowerManagementMode(cnvmlDevice, cMode) + __ret := C.dispatch_nvmlDeviceGetPowerManagementMode(cnvmlDevice, cMode) __v := (Return)(__ret) return __v } @@ -1002,7 +1001,7 @@ func nvmlDeviceGetPowerManagementMode(nvmlDevice nvmlDevice, Mode *EnableState) func nvmlDeviceGetPowerManagementLimit(nvmlDevice nvmlDevice, Limit *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cLimit, _ := (*C.uint)(unsafe.Pointer(Limit)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPowerManagementLimit(cnvmlDevice, cLimit) + __ret := C.dispatch_nvmlDeviceGetPowerManagementLimit(cnvmlDevice, cLimit) __v := (Return)(__ret) return __v } @@ -1012,7 +1011,7 @@ func nvmlDeviceGetPowerManagementLimitConstraints(nvmlDevice nvmlDevice, MinLimi cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMinLimit, _ := (*C.uint)(unsafe.Pointer(MinLimit)), cgoAllocsUnknown cMaxLimit, _ := (*C.uint)(unsafe.Pointer(MaxLimit)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPowerManagementLimitConstraints(cnvmlDevice, cMinLimit, cMaxLimit) + __ret := C.dispatch_nvmlDeviceGetPowerManagementLimitConstraints(cnvmlDevice, cMinLimit, cMaxLimit) __v := (Return)(__ret) return __v } @@ -1021,7 +1020,7 @@ func nvmlDeviceGetPowerManagementLimitConstraints(nvmlDevice nvmlDevice, MinLimi func nvmlDeviceGetPowerManagementDefaultLimit(nvmlDevice nvmlDevice, DefaultLimit *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cDefaultLimit, _ := (*C.uint)(unsafe.Pointer(DefaultLimit)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPowerManagementDefaultLimit(cnvmlDevice, cDefaultLimit) + __ret := C.dispatch_nvmlDeviceGetPowerManagementDefaultLimit(cnvmlDevice, cDefaultLimit) __v := (Return)(__ret) return __v } @@ -1030,7 +1029,7 @@ func nvmlDeviceGetPowerManagementDefaultLimit(nvmlDevice nvmlDevice, DefaultLimi func nvmlDeviceGetPowerUsage(nvmlDevice nvmlDevice, Power *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPower, _ := (*C.uint)(unsafe.Pointer(Power)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPowerUsage(cnvmlDevice, cPower) + __ret := C.dispatch_nvmlDeviceGetPowerUsage(cnvmlDevice, cPower) __v := (Return)(__ret) return __v } @@ -1039,7 +1038,7 @@ func nvmlDeviceGetPowerUsage(nvmlDevice nvmlDevice, Power *uint32) Return { func nvmlDeviceGetPowerMizerMode_v1(nvmlDevice nvmlDevice, PowerMizerMode *DevicePowerMizerModes_v1) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPowerMizerMode, _ := (*C.nvmlDevicePowerMizerModes_v1_t)(unsafe.Pointer(PowerMizerMode)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPowerMizerMode_v1(cnvmlDevice, cPowerMizerMode) + __ret := C.dispatch_nvmlDeviceGetPowerMizerMode_v1(cnvmlDevice, cPowerMizerMode) __v := (Return)(__ret) return __v } @@ -1048,7 +1047,7 @@ func nvmlDeviceGetPowerMizerMode_v1(nvmlDevice nvmlDevice, PowerMizerMode *Devic func nvmlDeviceSetPowerMizerMode_v1(nvmlDevice nvmlDevice, PowerMizerMode *DevicePowerMizerModes_v1) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPowerMizerMode, _ := (*C.nvmlDevicePowerMizerModes_v1_t)(unsafe.Pointer(PowerMizerMode)), cgoAllocsUnknown - __ret := C.nvmlDeviceSetPowerMizerMode_v1(cnvmlDevice, cPowerMizerMode) + __ret := C.dispatch_nvmlDeviceSetPowerMizerMode_v1(cnvmlDevice, cPowerMizerMode) __v := (Return)(__ret) return __v } @@ -1057,7 +1056,7 @@ func nvmlDeviceSetPowerMizerMode_v1(nvmlDevice nvmlDevice, PowerMizerMode *Devic func nvmlDeviceGetTotalEnergyConsumption(nvmlDevice nvmlDevice, Energy *uint64) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cEnergy, _ := (*C.ulonglong)(unsafe.Pointer(Energy)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetTotalEnergyConsumption(cnvmlDevice, cEnergy) + __ret := C.dispatch_nvmlDeviceGetTotalEnergyConsumption(cnvmlDevice, cEnergy) __v := (Return)(__ret) return __v } @@ -1066,7 +1065,7 @@ func nvmlDeviceGetTotalEnergyConsumption(nvmlDevice nvmlDevice, Energy *uint64) func nvmlDeviceGetEnforcedPowerLimit(nvmlDevice nvmlDevice, Limit *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cLimit, _ := (*C.uint)(unsafe.Pointer(Limit)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetEnforcedPowerLimit(cnvmlDevice, cLimit) + __ret := C.dispatch_nvmlDeviceGetEnforcedPowerLimit(cnvmlDevice, cLimit) __v := (Return)(__ret) return __v } @@ -1076,7 +1075,7 @@ func nvmlDeviceGetGpuOperationMode(nvmlDevice nvmlDevice, Current *GpuOperationM cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCurrent, _ := (*C.nvmlGpuOperationMode_t)(unsafe.Pointer(Current)), cgoAllocsUnknown cPending, _ := (*C.nvmlGpuOperationMode_t)(unsafe.Pointer(Pending)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpuOperationMode(cnvmlDevice, cCurrent, cPending) + __ret := C.dispatch_nvmlDeviceGetGpuOperationMode(cnvmlDevice, cCurrent, cPending) __v := (Return)(__ret) return __v } @@ -1085,7 +1084,7 @@ func nvmlDeviceGetGpuOperationMode(nvmlDevice nvmlDevice, Current *GpuOperationM func nvmlDeviceGetMemoryInfo(nvmlDevice nvmlDevice, Memory *Memory) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMemory, _ := (*C.nvmlMemory_t)(unsafe.Pointer(Memory)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMemoryInfo(cnvmlDevice, cMemory) + __ret := C.dispatch_nvmlDeviceGetMemoryInfo(cnvmlDevice, cMemory) __v := (Return)(__ret) return __v } @@ -1094,7 +1093,7 @@ func nvmlDeviceGetMemoryInfo(nvmlDevice nvmlDevice, Memory *Memory) Return { func nvmlDeviceGetMemoryInfo_v2(nvmlDevice nvmlDevice, Memory *Memory_v2) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMemory, _ := (*C.nvmlMemory_v2_t)(unsafe.Pointer(Memory)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMemoryInfo_v2(cnvmlDevice, cMemory) + __ret := C.dispatch_nvmlDeviceGetMemoryInfo_v2(cnvmlDevice, cMemory) __v := (Return)(__ret) return __v } @@ -1103,7 +1102,7 @@ func nvmlDeviceGetMemoryInfo_v2(nvmlDevice nvmlDevice, Memory *Memory_v2) Return func nvmlDeviceGetComputeMode(nvmlDevice nvmlDevice, Mode *ComputeMode) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMode, _ := (*C.nvmlComputeMode_t)(unsafe.Pointer(Mode)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetComputeMode(cnvmlDevice, cMode) + __ret := C.dispatch_nvmlDeviceGetComputeMode(cnvmlDevice, cMode) __v := (Return)(__ret) return __v } @@ -1113,7 +1112,7 @@ func nvmlDeviceGetCudaComputeCapability(nvmlDevice nvmlDevice, Major *int32, Min cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMajor, _ := (*C.int)(unsafe.Pointer(Major)), cgoAllocsUnknown cMinor, _ := (*C.int)(unsafe.Pointer(Minor)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetCudaComputeCapability(cnvmlDevice, cMajor, cMinor) + __ret := C.dispatch_nvmlDeviceGetCudaComputeCapability(cnvmlDevice, cMajor, cMinor) __v := (Return)(__ret) return __v } @@ -1123,7 +1122,7 @@ func nvmlDeviceGetDramEncryptionMode(nvmlDevice nvmlDevice, Current *DramEncrypt cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCurrent, _ := (*C.nvmlDramEncryptionInfo_t)(unsafe.Pointer(Current)), cgoAllocsUnknown cPending, _ := (*C.nvmlDramEncryptionInfo_t)(unsafe.Pointer(Pending)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetDramEncryptionMode(cnvmlDevice, cCurrent, cPending) + __ret := C.dispatch_nvmlDeviceGetDramEncryptionMode(cnvmlDevice, cCurrent, cPending) __v := (Return)(__ret) return __v } @@ -1132,7 +1131,7 @@ func nvmlDeviceGetDramEncryptionMode(nvmlDevice nvmlDevice, Current *DramEncrypt func nvmlDeviceSetDramEncryptionMode(nvmlDevice nvmlDevice, DramEncryption *DramEncryptionInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cDramEncryption, _ := (*C.nvmlDramEncryptionInfo_t)(unsafe.Pointer(DramEncryption)), cgoAllocsUnknown - __ret := C.nvmlDeviceSetDramEncryptionMode(cnvmlDevice, cDramEncryption) + __ret := C.dispatch_nvmlDeviceSetDramEncryptionMode(cnvmlDevice, cDramEncryption) __v := (Return)(__ret) return __v } @@ -1142,7 +1141,7 @@ func nvmlDeviceGetEccMode(nvmlDevice nvmlDevice, Current *EnableState, Pending * cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCurrent, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(Current)), cgoAllocsUnknown cPending, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(Pending)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetEccMode(cnvmlDevice, cCurrent, cPending) + __ret := C.dispatch_nvmlDeviceGetEccMode(cnvmlDevice, cCurrent, cPending) __v := (Return)(__ret) return __v } @@ -1151,7 +1150,7 @@ func nvmlDeviceGetEccMode(nvmlDevice nvmlDevice, Current *EnableState, Pending * func nvmlDeviceGetDefaultEccMode(nvmlDevice nvmlDevice, DefaultMode *EnableState) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cDefaultMode, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(DefaultMode)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetDefaultEccMode(cnvmlDevice, cDefaultMode) + __ret := C.dispatch_nvmlDeviceGetDefaultEccMode(cnvmlDevice, cDefaultMode) __v := (Return)(__ret) return __v } @@ -1160,7 +1159,7 @@ func nvmlDeviceGetDefaultEccMode(nvmlDevice nvmlDevice, DefaultMode *EnableState func nvmlDeviceGetBoardId(nvmlDevice nvmlDevice, BoardId *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cBoardId, _ := (*C.uint)(unsafe.Pointer(BoardId)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetBoardId(cnvmlDevice, cBoardId) + __ret := C.dispatch_nvmlDeviceGetBoardId(cnvmlDevice, cBoardId) __v := (Return)(__ret) return __v } @@ -1169,7 +1168,7 @@ func nvmlDeviceGetBoardId(nvmlDevice nvmlDevice, BoardId *uint32) Return { func nvmlDeviceGetMultiGpuBoard(nvmlDevice nvmlDevice, MultiGpuBool *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMultiGpuBool, _ := (*C.uint)(unsafe.Pointer(MultiGpuBool)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMultiGpuBoard(cnvmlDevice, cMultiGpuBool) + __ret := C.dispatch_nvmlDeviceGetMultiGpuBoard(cnvmlDevice, cMultiGpuBool) __v := (Return)(__ret) return __v } @@ -1180,7 +1179,7 @@ func nvmlDeviceGetTotalEccErrors(nvmlDevice nvmlDevice, ErrorType MemoryErrorTyp cErrorType, _ := (C.nvmlMemoryErrorType_t)(ErrorType), cgoAllocsUnknown cCounterType, _ := (C.nvmlEccCounterType_t)(CounterType), cgoAllocsUnknown cEccCounts, _ := (*C.ulonglong)(unsafe.Pointer(EccCounts)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetTotalEccErrors(cnvmlDevice, cErrorType, cCounterType, cEccCounts) + __ret := C.dispatch_nvmlDeviceGetTotalEccErrors(cnvmlDevice, cErrorType, cCounterType, cEccCounts) __v := (Return)(__ret) return __v } @@ -1191,7 +1190,7 @@ func nvmlDeviceGetDetailedEccErrors(nvmlDevice nvmlDevice, ErrorType MemoryError cErrorType, _ := (C.nvmlMemoryErrorType_t)(ErrorType), cgoAllocsUnknown cCounterType, _ := (C.nvmlEccCounterType_t)(CounterType), cgoAllocsUnknown cEccCounts, _ := (*C.nvmlEccErrorCounts_t)(unsafe.Pointer(EccCounts)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetDetailedEccErrors(cnvmlDevice, cErrorType, cCounterType, cEccCounts) + __ret := C.dispatch_nvmlDeviceGetDetailedEccErrors(cnvmlDevice, cErrorType, cCounterType, cEccCounts) __v := (Return)(__ret) return __v } @@ -1203,7 +1202,7 @@ func nvmlDeviceGetMemoryErrorCounter(nvmlDevice nvmlDevice, ErrorType MemoryErro cCounterType, _ := (C.nvmlEccCounterType_t)(CounterType), cgoAllocsUnknown cLocationType, _ := (C.nvmlMemoryLocation_t)(LocationType), cgoAllocsUnknown cCount, _ := (*C.ulonglong)(unsafe.Pointer(Count)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMemoryErrorCounter(cnvmlDevice, cErrorType, cCounterType, cLocationType, cCount) + __ret := C.dispatch_nvmlDeviceGetMemoryErrorCounter(cnvmlDevice, cErrorType, cCounterType, cLocationType, cCount) __v := (Return)(__ret) return __v } @@ -1212,7 +1211,7 @@ func nvmlDeviceGetMemoryErrorCounter(nvmlDevice nvmlDevice, ErrorType MemoryErro func nvmlDeviceGetUtilizationRates(nvmlDevice nvmlDevice, Utilization *Utilization) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cUtilization, _ := (*C.nvmlUtilization_t)(unsafe.Pointer(Utilization)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetUtilizationRates(cnvmlDevice, cUtilization) + __ret := C.dispatch_nvmlDeviceGetUtilizationRates(cnvmlDevice, cUtilization) __v := (Return)(__ret) return __v } @@ -1222,7 +1221,7 @@ func nvmlDeviceGetEncoderUtilization(nvmlDevice nvmlDevice, Utilization *uint32, cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cUtilization, _ := (*C.uint)(unsafe.Pointer(Utilization)), cgoAllocsUnknown cSamplingPeriodUs, _ := (*C.uint)(unsafe.Pointer(SamplingPeriodUs)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetEncoderUtilization(cnvmlDevice, cUtilization, cSamplingPeriodUs) + __ret := C.dispatch_nvmlDeviceGetEncoderUtilization(cnvmlDevice, cUtilization, cSamplingPeriodUs) __v := (Return)(__ret) return __v } @@ -1232,7 +1231,7 @@ func nvmlDeviceGetEncoderCapacity(nvmlDevice nvmlDevice, EncoderQueryType Encode cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cEncoderQueryType, _ := (C.nvmlEncoderType_t)(EncoderQueryType), cgoAllocsUnknown cEncoderCapacity, _ := (*C.uint)(unsafe.Pointer(EncoderCapacity)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetEncoderCapacity(cnvmlDevice, cEncoderQueryType, cEncoderCapacity) + __ret := C.dispatch_nvmlDeviceGetEncoderCapacity(cnvmlDevice, cEncoderQueryType, cEncoderCapacity) __v := (Return)(__ret) return __v } @@ -1243,7 +1242,7 @@ func nvmlDeviceGetEncoderStats(nvmlDevice nvmlDevice, SessionCount *uint32, Aver cSessionCount, _ := (*C.uint)(unsafe.Pointer(SessionCount)), cgoAllocsUnknown cAverageFps, _ := (*C.uint)(unsafe.Pointer(AverageFps)), cgoAllocsUnknown cAverageLatency, _ := (*C.uint)(unsafe.Pointer(AverageLatency)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetEncoderStats(cnvmlDevice, cSessionCount, cAverageFps, cAverageLatency) + __ret := C.dispatch_nvmlDeviceGetEncoderStats(cnvmlDevice, cSessionCount, cAverageFps, cAverageLatency) __v := (Return)(__ret) return __v } @@ -1253,7 +1252,7 @@ func nvmlDeviceGetEncoderSessions(nvmlDevice nvmlDevice, SessionCount *uint32, S cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cSessionCount, _ := (*C.uint)(unsafe.Pointer(SessionCount)), cgoAllocsUnknown cSessionInfos, _ := (*C.nvmlEncoderSessionInfo_t)(unsafe.Pointer(SessionInfos)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetEncoderSessions(cnvmlDevice, cSessionCount, cSessionInfos) + __ret := C.dispatch_nvmlDeviceGetEncoderSessions(cnvmlDevice, cSessionCount, cSessionInfos) __v := (Return)(__ret) return __v } @@ -1263,7 +1262,7 @@ func nvmlDeviceGetDecoderUtilization(nvmlDevice nvmlDevice, Utilization *uint32, cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cUtilization, _ := (*C.uint)(unsafe.Pointer(Utilization)), cgoAllocsUnknown cSamplingPeriodUs, _ := (*C.uint)(unsafe.Pointer(SamplingPeriodUs)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetDecoderUtilization(cnvmlDevice, cUtilization, cSamplingPeriodUs) + __ret := C.dispatch_nvmlDeviceGetDecoderUtilization(cnvmlDevice, cUtilization, cSamplingPeriodUs) __v := (Return)(__ret) return __v } @@ -1273,7 +1272,7 @@ func nvmlDeviceGetJpgUtilization(nvmlDevice nvmlDevice, Utilization *uint32, Sam cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cUtilization, _ := (*C.uint)(unsafe.Pointer(Utilization)), cgoAllocsUnknown cSamplingPeriodUs, _ := (*C.uint)(unsafe.Pointer(SamplingPeriodUs)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetJpgUtilization(cnvmlDevice, cUtilization, cSamplingPeriodUs) + __ret := C.dispatch_nvmlDeviceGetJpgUtilization(cnvmlDevice, cUtilization, cSamplingPeriodUs) __v := (Return)(__ret) return __v } @@ -1283,7 +1282,7 @@ func nvmlDeviceGetOfaUtilization(nvmlDevice nvmlDevice, Utilization *uint32, Sam cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cUtilization, _ := (*C.uint)(unsafe.Pointer(Utilization)), cgoAllocsUnknown cSamplingPeriodUs, _ := (*C.uint)(unsafe.Pointer(SamplingPeriodUs)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetOfaUtilization(cnvmlDevice, cUtilization, cSamplingPeriodUs) + __ret := C.dispatch_nvmlDeviceGetOfaUtilization(cnvmlDevice, cUtilization, cSamplingPeriodUs) __v := (Return)(__ret) return __v } @@ -1292,7 +1291,7 @@ func nvmlDeviceGetOfaUtilization(nvmlDevice nvmlDevice, Utilization *uint32, Sam func nvmlDeviceGetFBCStats(nvmlDevice nvmlDevice, FbcStats *FBCStats) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cFbcStats, _ := (*C.nvmlFBCStats_t)(unsafe.Pointer(FbcStats)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetFBCStats(cnvmlDevice, cFbcStats) + __ret := C.dispatch_nvmlDeviceGetFBCStats(cnvmlDevice, cFbcStats) __v := (Return)(__ret) return __v } @@ -1302,7 +1301,7 @@ func nvmlDeviceGetFBCSessions(nvmlDevice nvmlDevice, SessionCount *uint32, Sessi cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cSessionCount, _ := (*C.uint)(unsafe.Pointer(SessionCount)), cgoAllocsUnknown cSessionInfo, _ := (*C.nvmlFBCSessionInfo_t)(unsafe.Pointer(SessionInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetFBCSessions(cnvmlDevice, cSessionCount, cSessionInfo) + __ret := C.dispatch_nvmlDeviceGetFBCSessions(cnvmlDevice, cSessionCount, cSessionInfo) __v := (Return)(__ret) return __v } @@ -1312,7 +1311,7 @@ func nvmlDeviceGetDriverModel_v2(nvmlDevice nvmlDevice, Current *DriverModel, Pe cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCurrent, _ := (*C.nvmlDriverModel_t)(unsafe.Pointer(Current)), cgoAllocsUnknown cPending, _ := (*C.nvmlDriverModel_t)(unsafe.Pointer(Pending)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetDriverModel_v2(cnvmlDevice, cCurrent, cPending) + __ret := C.dispatch_nvmlDeviceGetDriverModel_v2(cnvmlDevice, cCurrent, cPending) __v := (Return)(__ret) return __v } @@ -1322,7 +1321,7 @@ func nvmlDeviceGetVbiosVersion(nvmlDevice nvmlDevice, Version *byte, Length uint cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cVersion, _ := (*C.char)(unsafe.Pointer(Version)), cgoAllocsUnknown cLength, _ := (C.uint)(Length), cgoAllocsUnknown - __ret := C.nvmlDeviceGetVbiosVersion(cnvmlDevice, cVersion, cLength) + __ret := C.dispatch_nvmlDeviceGetVbiosVersion(cnvmlDevice, cVersion, cLength) __v := (Return)(__ret) return __v } @@ -1331,7 +1330,7 @@ func nvmlDeviceGetVbiosVersion(nvmlDevice nvmlDevice, Version *byte, Length uint func nvmlDeviceGetBridgeChipInfo(nvmlDevice nvmlDevice, BridgeHierarchy *BridgeChipHierarchy) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cBridgeHierarchy, _ := (*C.nvmlBridgeChipHierarchy_t)(unsafe.Pointer(BridgeHierarchy)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetBridgeChipInfo(cnvmlDevice, cBridgeHierarchy) + __ret := C.dispatch_nvmlDeviceGetBridgeChipInfo(cnvmlDevice, cBridgeHierarchy) __v := (Return)(__ret) return __v } @@ -1341,7 +1340,7 @@ func nvmlDeviceGetComputeRunningProcesses_v3(nvmlDevice nvmlDevice, InfoCount *u cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cInfoCount, _ := (*C.uint)(unsafe.Pointer(InfoCount)), cgoAllocsUnknown cInfos, _ := (*C.nvmlProcessInfo_t)(unsafe.Pointer(Infos)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetComputeRunningProcesses_v3(cnvmlDevice, cInfoCount, cInfos) + __ret := C.dispatch_nvmlDeviceGetComputeRunningProcesses_v3(cnvmlDevice, cInfoCount, cInfos) __v := (Return)(__ret) return __v } @@ -1351,7 +1350,7 @@ func nvmlDeviceGetGraphicsRunningProcesses_v3(nvmlDevice nvmlDevice, InfoCount * cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cInfoCount, _ := (*C.uint)(unsafe.Pointer(InfoCount)), cgoAllocsUnknown cInfos, _ := (*C.nvmlProcessInfo_t)(unsafe.Pointer(Infos)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGraphicsRunningProcesses_v3(cnvmlDevice, cInfoCount, cInfos) + __ret := C.dispatch_nvmlDeviceGetGraphicsRunningProcesses_v3(cnvmlDevice, cInfoCount, cInfos) __v := (Return)(__ret) return __v } @@ -1361,7 +1360,7 @@ func nvmlDeviceGetMPSComputeRunningProcesses_v3(nvmlDevice nvmlDevice, InfoCount cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cInfoCount, _ := (*C.uint)(unsafe.Pointer(InfoCount)), cgoAllocsUnknown cInfos, _ := (*C.nvmlProcessInfo_t)(unsafe.Pointer(Infos)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMPSComputeRunningProcesses_v3(cnvmlDevice, cInfoCount, cInfos) + __ret := C.dispatch_nvmlDeviceGetMPSComputeRunningProcesses_v3(cnvmlDevice, cInfoCount, cInfos) __v := (Return)(__ret) return __v } @@ -1370,7 +1369,7 @@ func nvmlDeviceGetMPSComputeRunningProcesses_v3(nvmlDevice nvmlDevice, InfoCount func nvmlDeviceGetRunningProcessDetailList(nvmlDevice nvmlDevice, Plist *ProcessDetailList) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPlist, _ := (*C.nvmlProcessDetailList_t)(unsafe.Pointer(Plist)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetRunningProcessDetailList(cnvmlDevice, cPlist) + __ret := C.dispatch_nvmlDeviceGetRunningProcessDetailList(cnvmlDevice, cPlist) __v := (Return)(__ret) return __v } @@ -1380,7 +1379,7 @@ func nvmlDeviceOnSameBoard(Device1 nvmlDevice, Device2 nvmlDevice, OnSameBoard * cDevice1, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&Device1)), cgoAllocsUnknown cDevice2, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&Device2)), cgoAllocsUnknown cOnSameBoard, _ := (*C.int)(unsafe.Pointer(OnSameBoard)), cgoAllocsUnknown - __ret := C.nvmlDeviceOnSameBoard(cDevice1, cDevice2, cOnSameBoard) + __ret := C.dispatch_nvmlDeviceOnSameBoard(cDevice1, cDevice2, cOnSameBoard) __v := (Return)(__ret) return __v } @@ -1390,7 +1389,7 @@ func nvmlDeviceGetAPIRestriction(nvmlDevice nvmlDevice, ApiType RestrictedAPI, I cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cApiType, _ := (C.nvmlRestrictedAPI_t)(ApiType), cgoAllocsUnknown cIsRestricted, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(IsRestricted)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetAPIRestriction(cnvmlDevice, cApiType, cIsRestricted) + __ret := C.dispatch_nvmlDeviceGetAPIRestriction(cnvmlDevice, cApiType, cIsRestricted) __v := (Return)(__ret) return __v } @@ -1403,7 +1402,7 @@ func nvmlDeviceGetSamples(nvmlDevice nvmlDevice, _type SamplingType, LastSeenTim cSampleValType, _ := (*C.nvmlValueType_t)(unsafe.Pointer(SampleValType)), cgoAllocsUnknown cSampleCount, _ := (*C.uint)(unsafe.Pointer(SampleCount)), cgoAllocsUnknown cSamples, _ := (*C.nvmlSample_t)(unsafe.Pointer(Samples)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetSamples(cnvmlDevice, c_type, cLastSeenTimeStamp, cSampleValType, cSampleCount, cSamples) + __ret := C.dispatch_nvmlDeviceGetSamples(cnvmlDevice, c_type, cLastSeenTimeStamp, cSampleValType, cSampleCount, cSamples) __v := (Return)(__ret) return __v } @@ -1412,7 +1411,7 @@ func nvmlDeviceGetSamples(nvmlDevice nvmlDevice, _type SamplingType, LastSeenTim func nvmlDeviceGetBAR1MemoryInfo(nvmlDevice nvmlDevice, Bar1Memory *BAR1Memory) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cBar1Memory, _ := (*C.nvmlBAR1Memory_t)(unsafe.Pointer(Bar1Memory)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetBAR1MemoryInfo(cnvmlDevice, cBar1Memory) + __ret := C.dispatch_nvmlDeviceGetBAR1MemoryInfo(cnvmlDevice, cBar1Memory) __v := (Return)(__ret) return __v } @@ -1422,7 +1421,7 @@ func nvmlDeviceGetViolationStatus(nvmlDevice nvmlDevice, PerfPolicyType PerfPoli cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPerfPolicyType, _ := (C.nvmlPerfPolicyType_t)(PerfPolicyType), cgoAllocsUnknown cViolTime, _ := (*C.nvmlViolationTime_t)(unsafe.Pointer(ViolTime)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetViolationStatus(cnvmlDevice, cPerfPolicyType, cViolTime) + __ret := C.dispatch_nvmlDeviceGetViolationStatus(cnvmlDevice, cPerfPolicyType, cViolTime) __v := (Return)(__ret) return __v } @@ -1431,7 +1430,7 @@ func nvmlDeviceGetViolationStatus(nvmlDevice nvmlDevice, PerfPolicyType PerfPoli func nvmlDeviceGetIrqNum(nvmlDevice nvmlDevice, IrqNum *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cIrqNum, _ := (*C.uint)(unsafe.Pointer(IrqNum)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetIrqNum(cnvmlDevice, cIrqNum) + __ret := C.dispatch_nvmlDeviceGetIrqNum(cnvmlDevice, cIrqNum) __v := (Return)(__ret) return __v } @@ -1440,7 +1439,7 @@ func nvmlDeviceGetIrqNum(nvmlDevice nvmlDevice, IrqNum *uint32) Return { func nvmlDeviceGetNumGpuCores(nvmlDevice nvmlDevice, NumCores *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cNumCores, _ := (*C.uint)(unsafe.Pointer(NumCores)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNumGpuCores(cnvmlDevice, cNumCores) + __ret := C.dispatch_nvmlDeviceGetNumGpuCores(cnvmlDevice, cNumCores) __v := (Return)(__ret) return __v } @@ -1449,7 +1448,7 @@ func nvmlDeviceGetNumGpuCores(nvmlDevice nvmlDevice, NumCores *uint32) Return { func nvmlDeviceGetPowerSource(nvmlDevice nvmlDevice, PowerSource *PowerSource) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPowerSource, _ := (*C.nvmlPowerSource_t)(unsafe.Pointer(PowerSource)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPowerSource(cnvmlDevice, cPowerSource) + __ret := C.dispatch_nvmlDeviceGetPowerSource(cnvmlDevice, cPowerSource) __v := (Return)(__ret) return __v } @@ -1458,7 +1457,7 @@ func nvmlDeviceGetPowerSource(nvmlDevice nvmlDevice, PowerSource *PowerSource) R func nvmlDeviceGetMemoryBusWidth(nvmlDevice nvmlDevice, BusWidth *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cBusWidth, _ := (*C.uint)(unsafe.Pointer(BusWidth)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMemoryBusWidth(cnvmlDevice, cBusWidth) + __ret := C.dispatch_nvmlDeviceGetMemoryBusWidth(cnvmlDevice, cBusWidth) __v := (Return)(__ret) return __v } @@ -1467,7 +1466,7 @@ func nvmlDeviceGetMemoryBusWidth(nvmlDevice nvmlDevice, BusWidth *uint32) Return func nvmlDeviceGetPcieLinkMaxSpeed(nvmlDevice nvmlDevice, MaxSpeed *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMaxSpeed, _ := (*C.uint)(unsafe.Pointer(MaxSpeed)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPcieLinkMaxSpeed(cnvmlDevice, cMaxSpeed) + __ret := C.dispatch_nvmlDeviceGetPcieLinkMaxSpeed(cnvmlDevice, cMaxSpeed) __v := (Return)(__ret) return __v } @@ -1476,7 +1475,7 @@ func nvmlDeviceGetPcieLinkMaxSpeed(nvmlDevice nvmlDevice, MaxSpeed *uint32) Retu func nvmlDeviceGetPcieSpeed(nvmlDevice nvmlDevice, PcieSpeed *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPcieSpeed, _ := (*C.uint)(unsafe.Pointer(PcieSpeed)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPcieSpeed(cnvmlDevice, cPcieSpeed) + __ret := C.dispatch_nvmlDeviceGetPcieSpeed(cnvmlDevice, cPcieSpeed) __v := (Return)(__ret) return __v } @@ -1485,7 +1484,7 @@ func nvmlDeviceGetPcieSpeed(nvmlDevice nvmlDevice, PcieSpeed *uint32) Return { func nvmlDeviceGetAdaptiveClockInfoStatus(nvmlDevice nvmlDevice, AdaptiveClockStatus *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cAdaptiveClockStatus, _ := (*C.uint)(unsafe.Pointer(AdaptiveClockStatus)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetAdaptiveClockInfoStatus(cnvmlDevice, cAdaptiveClockStatus) + __ret := C.dispatch_nvmlDeviceGetAdaptiveClockInfoStatus(cnvmlDevice, cAdaptiveClockStatus) __v := (Return)(__ret) return __v } @@ -1494,7 +1493,7 @@ func nvmlDeviceGetAdaptiveClockInfoStatus(nvmlDevice nvmlDevice, AdaptiveClockSt func nvmlDeviceGetBusType(nvmlDevice nvmlDevice, _type *BusType) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown c_type, _ := (*C.nvmlBusType_t)(unsafe.Pointer(_type)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetBusType(cnvmlDevice, c_type) + __ret := C.dispatch_nvmlDeviceGetBusType(cnvmlDevice, c_type) __v := (Return)(__ret) return __v } @@ -1503,7 +1502,7 @@ func nvmlDeviceGetBusType(nvmlDevice nvmlDevice, _type *BusType) Return { func nvmlDeviceGetGpuFabricInfo(nvmlDevice nvmlDevice, GpuFabricInfo *GpuFabricInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cGpuFabricInfo, _ := (*C.nvmlGpuFabricInfo_t)(unsafe.Pointer(GpuFabricInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpuFabricInfo(cnvmlDevice, cGpuFabricInfo) + __ret := C.dispatch_nvmlDeviceGetGpuFabricInfo(cnvmlDevice, cGpuFabricInfo) __v := (Return)(__ret) return __v } @@ -1512,7 +1511,7 @@ func nvmlDeviceGetGpuFabricInfo(nvmlDevice nvmlDevice, GpuFabricInfo *GpuFabricI func nvmlDeviceGetGpuFabricInfoV(nvmlDevice nvmlDevice, GpuFabricInfo *GpuFabricInfoV) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cGpuFabricInfo, _ := (*C.nvmlGpuFabricInfoV_t)(unsafe.Pointer(GpuFabricInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpuFabricInfoV(cnvmlDevice, cGpuFabricInfo) + __ret := C.dispatch_nvmlDeviceGetGpuFabricInfoV(cnvmlDevice, cGpuFabricInfo) __v := (Return)(__ret) return __v } @@ -1520,7 +1519,7 @@ func nvmlDeviceGetGpuFabricInfoV(nvmlDevice nvmlDevice, GpuFabricInfo *GpuFabric // nvmlSystemGetConfComputeCapabilities function as declared in nvml/nvml.h func nvmlSystemGetConfComputeCapabilities(Capabilities *ConfComputeSystemCaps) Return { cCapabilities, _ := (*C.nvmlConfComputeSystemCaps_t)(unsafe.Pointer(Capabilities)), cgoAllocsUnknown - __ret := C.nvmlSystemGetConfComputeCapabilities(cCapabilities) + __ret := C.dispatch_nvmlSystemGetConfComputeCapabilities(cCapabilities) __v := (Return)(__ret) return __v } @@ -1528,7 +1527,7 @@ func nvmlSystemGetConfComputeCapabilities(Capabilities *ConfComputeSystemCaps) R // nvmlSystemGetConfComputeState function as declared in nvml/nvml.h func nvmlSystemGetConfComputeState(State *ConfComputeSystemState) Return { cState, _ := (*C.nvmlConfComputeSystemState_t)(unsafe.Pointer(State)), cgoAllocsUnknown - __ret := C.nvmlSystemGetConfComputeState(cState) + __ret := C.dispatch_nvmlSystemGetConfComputeState(cState) __v := (Return)(__ret) return __v } @@ -1537,7 +1536,7 @@ func nvmlSystemGetConfComputeState(State *ConfComputeSystemState) Return { func nvmlDeviceGetConfComputeMemSizeInfo(nvmlDevice nvmlDevice, MemInfo *ConfComputeMemSizeInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMemInfo, _ := (*C.nvmlConfComputeMemSizeInfo_t)(unsafe.Pointer(MemInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetConfComputeMemSizeInfo(cnvmlDevice, cMemInfo) + __ret := C.dispatch_nvmlDeviceGetConfComputeMemSizeInfo(cnvmlDevice, cMemInfo) __v := (Return)(__ret) return __v } @@ -1545,7 +1544,7 @@ func nvmlDeviceGetConfComputeMemSizeInfo(nvmlDevice nvmlDevice, MemInfo *ConfCom // nvmlSystemGetConfComputeGpusReadyState function as declared in nvml/nvml.h func nvmlSystemGetConfComputeGpusReadyState(IsAcceptingWork *uint32) Return { cIsAcceptingWork, _ := (*C.uint)(unsafe.Pointer(IsAcceptingWork)), cgoAllocsUnknown - __ret := C.nvmlSystemGetConfComputeGpusReadyState(cIsAcceptingWork) + __ret := C.dispatch_nvmlSystemGetConfComputeGpusReadyState(cIsAcceptingWork) __v := (Return)(__ret) return __v } @@ -1554,7 +1553,7 @@ func nvmlSystemGetConfComputeGpusReadyState(IsAcceptingWork *uint32) Return { func nvmlDeviceGetConfComputeProtectedMemoryUsage(nvmlDevice nvmlDevice, Memory *Memory) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMemory, _ := (*C.nvmlMemory_t)(unsafe.Pointer(Memory)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetConfComputeProtectedMemoryUsage(cnvmlDevice, cMemory) + __ret := C.dispatch_nvmlDeviceGetConfComputeProtectedMemoryUsage(cnvmlDevice, cMemory) __v := (Return)(__ret) return __v } @@ -1563,7 +1562,7 @@ func nvmlDeviceGetConfComputeProtectedMemoryUsage(nvmlDevice nvmlDevice, Memory func nvmlDeviceGetConfComputeGpuCertificate(nvmlDevice nvmlDevice, GpuCert *ConfComputeGpuCertificate) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cGpuCert, _ := (*C.nvmlConfComputeGpuCertificate_t)(unsafe.Pointer(GpuCert)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetConfComputeGpuCertificate(cnvmlDevice, cGpuCert) + __ret := C.dispatch_nvmlDeviceGetConfComputeGpuCertificate(cnvmlDevice, cGpuCert) __v := (Return)(__ret) return __v } @@ -1572,7 +1571,7 @@ func nvmlDeviceGetConfComputeGpuCertificate(nvmlDevice nvmlDevice, GpuCert *Conf func nvmlDeviceGetConfComputeGpuAttestationReport(nvmlDevice nvmlDevice, GpuAtstReport *ConfComputeGpuAttestationReport) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cGpuAtstReport, _ := (*C.nvmlConfComputeGpuAttestationReport_t)(unsafe.Pointer(GpuAtstReport)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetConfComputeGpuAttestationReport(cnvmlDevice, cGpuAtstReport) + __ret := C.dispatch_nvmlDeviceGetConfComputeGpuAttestationReport(cnvmlDevice, cGpuAtstReport) __v := (Return)(__ret) return __v } @@ -1580,7 +1579,7 @@ func nvmlDeviceGetConfComputeGpuAttestationReport(nvmlDevice nvmlDevice, GpuAtst // nvmlSystemGetConfComputeKeyRotationThresholdInfo function as declared in nvml/nvml.h func nvmlSystemGetConfComputeKeyRotationThresholdInfo(PKeyRotationThrInfo *ConfComputeGetKeyRotationThresholdInfo) Return { cPKeyRotationThrInfo, _ := (*C.nvmlConfComputeGetKeyRotationThresholdInfo_t)(unsafe.Pointer(PKeyRotationThrInfo)), cgoAllocsUnknown - __ret := C.nvmlSystemGetConfComputeKeyRotationThresholdInfo(cPKeyRotationThrInfo) + __ret := C.dispatch_nvmlSystemGetConfComputeKeyRotationThresholdInfo(cPKeyRotationThrInfo) __v := (Return)(__ret) return __v } @@ -1589,7 +1588,7 @@ func nvmlSystemGetConfComputeKeyRotationThresholdInfo(PKeyRotationThrInfo *ConfC func nvmlDeviceSetConfComputeUnprotectedMemSize(nvmlDevice nvmlDevice, SizeKiB uint64) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cSizeKiB, _ := (C.ulonglong)(SizeKiB), cgoAllocsUnknown - __ret := C.nvmlDeviceSetConfComputeUnprotectedMemSize(cnvmlDevice, cSizeKiB) + __ret := C.dispatch_nvmlDeviceSetConfComputeUnprotectedMemSize(cnvmlDevice, cSizeKiB) __v := (Return)(__ret) return __v } @@ -1597,7 +1596,7 @@ func nvmlDeviceSetConfComputeUnprotectedMemSize(nvmlDevice nvmlDevice, SizeKiB u // nvmlSystemSetConfComputeGpusReadyState function as declared in nvml/nvml.h func nvmlSystemSetConfComputeGpusReadyState(IsAcceptingWork uint32) Return { cIsAcceptingWork, _ := (C.uint)(IsAcceptingWork), cgoAllocsUnknown - __ret := C.nvmlSystemSetConfComputeGpusReadyState(cIsAcceptingWork) + __ret := C.dispatch_nvmlSystemSetConfComputeGpusReadyState(cIsAcceptingWork) __v := (Return)(__ret) return __v } @@ -1605,7 +1604,7 @@ func nvmlSystemSetConfComputeGpusReadyState(IsAcceptingWork uint32) Return { // nvmlSystemSetConfComputeKeyRotationThresholdInfo function as declared in nvml/nvml.h func nvmlSystemSetConfComputeKeyRotationThresholdInfo(PKeyRotationThrInfo *ConfComputeSetKeyRotationThresholdInfo) Return { cPKeyRotationThrInfo, _ := (*C.nvmlConfComputeSetKeyRotationThresholdInfo_t)(unsafe.Pointer(PKeyRotationThrInfo)), cgoAllocsUnknown - __ret := C.nvmlSystemSetConfComputeKeyRotationThresholdInfo(cPKeyRotationThrInfo) + __ret := C.dispatch_nvmlSystemSetConfComputeKeyRotationThresholdInfo(cPKeyRotationThrInfo) __v := (Return)(__ret) return __v } @@ -1613,7 +1612,7 @@ func nvmlSystemSetConfComputeKeyRotationThresholdInfo(PKeyRotationThrInfo *ConfC // nvmlSystemGetConfComputeSettings function as declared in nvml/nvml.h func nvmlSystemGetConfComputeSettings(Settings *SystemConfComputeSettings) Return { cSettings, _ := (*C.nvmlSystemConfComputeSettings_t)(unsafe.Pointer(Settings)), cgoAllocsUnknown - __ret := C.nvmlSystemGetConfComputeSettings(cSettings) + __ret := C.dispatch_nvmlSystemGetConfComputeSettings(cSettings) __v := (Return)(__ret) return __v } @@ -1622,7 +1621,7 @@ func nvmlSystemGetConfComputeSettings(Settings *SystemConfComputeSettings) Retur func nvmlDeviceGetGspFirmwareVersion(nvmlDevice nvmlDevice, Version *byte) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cVersion, _ := (*C.char)(unsafe.Pointer(Version)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGspFirmwareVersion(cnvmlDevice, cVersion) + __ret := C.dispatch_nvmlDeviceGetGspFirmwareVersion(cnvmlDevice, cVersion) __v := (Return)(__ret) return __v } @@ -1632,7 +1631,7 @@ func nvmlDeviceGetGspFirmwareMode(nvmlDevice nvmlDevice, IsEnabled *uint32, Defa cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cIsEnabled, _ := (*C.uint)(unsafe.Pointer(IsEnabled)), cgoAllocsUnknown cDefaultMode, _ := (*C.uint)(unsafe.Pointer(DefaultMode)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGspFirmwareMode(cnvmlDevice, cIsEnabled, cDefaultMode) + __ret := C.dispatch_nvmlDeviceGetGspFirmwareMode(cnvmlDevice, cIsEnabled, cDefaultMode) __v := (Return)(__ret) return __v } @@ -1641,7 +1640,7 @@ func nvmlDeviceGetGspFirmwareMode(nvmlDevice nvmlDevice, IsEnabled *uint32, Defa func nvmlDeviceGetSramEccErrorStatus(nvmlDevice nvmlDevice, Status *EccSramErrorStatus) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cStatus, _ := (*C.nvmlEccSramErrorStatus_t)(unsafe.Pointer(Status)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetSramEccErrorStatus(cnvmlDevice, cStatus) + __ret := C.dispatch_nvmlDeviceGetSramEccErrorStatus(cnvmlDevice, cStatus) __v := (Return)(__ret) return __v } @@ -1650,7 +1649,7 @@ func nvmlDeviceGetSramEccErrorStatus(nvmlDevice nvmlDevice, Status *EccSramError func nvmlDeviceSetPowerManagementLimit_v2(nvmlDevice nvmlDevice, PowerValue *PowerValue_v2) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPowerValue, _ := (*C.nvmlPowerValue_v2_t)(unsafe.Pointer(PowerValue)), cgoAllocsUnknown - __ret := C.nvmlDeviceSetPowerManagementLimit_v2(cnvmlDevice, cPowerValue) + __ret := C.dispatch_nvmlDeviceSetPowerManagementLimit_v2(cnvmlDevice, cPowerValue) __v := (Return)(__ret) return __v } @@ -1659,7 +1658,7 @@ func nvmlDeviceSetPowerManagementLimit_v2(nvmlDevice nvmlDevice, PowerValue *Pow func nvmlDeviceGetAccountingMode(nvmlDevice nvmlDevice, Mode *EnableState) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMode, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(Mode)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetAccountingMode(cnvmlDevice, cMode) + __ret := C.dispatch_nvmlDeviceGetAccountingMode(cnvmlDevice, cMode) __v := (Return)(__ret) return __v } @@ -1669,7 +1668,7 @@ func nvmlDeviceGetAccountingStats(nvmlDevice nvmlDevice, Pid uint32, Stats *Acco cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPid, _ := (C.uint)(Pid), cgoAllocsUnknown cStats, _ := (*C.nvmlAccountingStats_t)(unsafe.Pointer(Stats)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetAccountingStats(cnvmlDevice, cPid, cStats) + __ret := C.dispatch_nvmlDeviceGetAccountingStats(cnvmlDevice, cPid, cStats) __v := (Return)(__ret) return __v } @@ -1679,7 +1678,7 @@ func nvmlDeviceGetAccountingPids(nvmlDevice nvmlDevice, Count *uint32, Pids *uin cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCount, _ := (*C.uint)(unsafe.Pointer(Count)), cgoAllocsUnknown cPids, _ := (*C.uint)(unsafe.Pointer(Pids)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetAccountingPids(cnvmlDevice, cCount, cPids) + __ret := C.dispatch_nvmlDeviceGetAccountingPids(cnvmlDevice, cCount, cPids) __v := (Return)(__ret) return __v } @@ -1688,7 +1687,7 @@ func nvmlDeviceGetAccountingPids(nvmlDevice nvmlDevice, Count *uint32, Pids *uin func nvmlDeviceGetAccountingBufferSize(nvmlDevice nvmlDevice, BufferSize *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cBufferSize, _ := (*C.uint)(unsafe.Pointer(BufferSize)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetAccountingBufferSize(cnvmlDevice, cBufferSize) + __ret := C.dispatch_nvmlDeviceGetAccountingBufferSize(cnvmlDevice, cBufferSize) __v := (Return)(__ret) return __v } @@ -1699,7 +1698,7 @@ func nvmlDeviceGetRetiredPages(nvmlDevice nvmlDevice, Cause PageRetirementCause, cCause, _ := (C.nvmlPageRetirementCause_t)(Cause), cgoAllocsUnknown cPageCount, _ := (*C.uint)(unsafe.Pointer(PageCount)), cgoAllocsUnknown cAddresses, _ := (*C.ulonglong)(unsafe.Pointer(Addresses)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetRetiredPages(cnvmlDevice, cCause, cPageCount, cAddresses) + __ret := C.dispatch_nvmlDeviceGetRetiredPages(cnvmlDevice, cCause, cPageCount, cAddresses) __v := (Return)(__ret) return __v } @@ -1711,7 +1710,7 @@ func nvmlDeviceGetRetiredPages_v2(nvmlDevice nvmlDevice, Cause PageRetirementCau cPageCount, _ := (*C.uint)(unsafe.Pointer(PageCount)), cgoAllocsUnknown cAddresses, _ := (*C.ulonglong)(unsafe.Pointer(Addresses)), cgoAllocsUnknown cTimestamps, _ := (*C.ulonglong)(unsafe.Pointer(Timestamps)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetRetiredPages_v2(cnvmlDevice, cCause, cPageCount, cAddresses, cTimestamps) + __ret := C.dispatch_nvmlDeviceGetRetiredPages_v2(cnvmlDevice, cCause, cPageCount, cAddresses, cTimestamps) __v := (Return)(__ret) return __v } @@ -1720,7 +1719,7 @@ func nvmlDeviceGetRetiredPages_v2(nvmlDevice nvmlDevice, Cause PageRetirementCau func nvmlDeviceGetRetiredPagesPendingStatus(nvmlDevice nvmlDevice, IsPending *EnableState) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cIsPending, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(IsPending)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetRetiredPagesPendingStatus(cnvmlDevice, cIsPending) + __ret := C.dispatch_nvmlDeviceGetRetiredPagesPendingStatus(cnvmlDevice, cIsPending) __v := (Return)(__ret) return __v } @@ -1732,7 +1731,7 @@ func nvmlDeviceGetRemappedRows(nvmlDevice nvmlDevice, CorrRows *uint32, UncRows cUncRows, _ := (*C.uint)(unsafe.Pointer(UncRows)), cgoAllocsUnknown cIsPending, _ := (*C.uint)(unsafe.Pointer(IsPending)), cgoAllocsUnknown cFailureOccurred, _ := (*C.uint)(unsafe.Pointer(FailureOccurred)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetRemappedRows(cnvmlDevice, cCorrRows, cUncRows, cIsPending, cFailureOccurred) + __ret := C.dispatch_nvmlDeviceGetRemappedRows(cnvmlDevice, cCorrRows, cUncRows, cIsPending, cFailureOccurred) __v := (Return)(__ret) return __v } @@ -1741,7 +1740,7 @@ func nvmlDeviceGetRemappedRows(nvmlDevice nvmlDevice, CorrRows *uint32, UncRows func nvmlDeviceGetRowRemapperHistogram(nvmlDevice nvmlDevice, Values *RowRemapperHistogramValues) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cValues, _ := (*C.nvmlRowRemapperHistogramValues_t)(unsafe.Pointer(Values)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetRowRemapperHistogram(cnvmlDevice, cValues) + __ret := C.dispatch_nvmlDeviceGetRowRemapperHistogram(cnvmlDevice, cValues) __v := (Return)(__ret) return __v } @@ -1750,7 +1749,7 @@ func nvmlDeviceGetRowRemapperHistogram(nvmlDevice nvmlDevice, Values *RowRemappe func nvmlDeviceGetArchitecture(nvmlDevice nvmlDevice, Arch *DeviceArchitecture) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cArch, _ := (*C.nvmlDeviceArchitecture_t)(unsafe.Pointer(Arch)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetArchitecture(cnvmlDevice, cArch) + __ret := C.dispatch_nvmlDeviceGetArchitecture(cnvmlDevice, cArch) __v := (Return)(__ret) return __v } @@ -1759,7 +1758,7 @@ func nvmlDeviceGetArchitecture(nvmlDevice nvmlDevice, Arch *DeviceArchitecture) func nvmlDeviceGetClkMonStatus(nvmlDevice nvmlDevice, Status *ClkMonStatus) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cStatus, _ := (*C.nvmlClkMonStatus_t)(unsafe.Pointer(Status)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetClkMonStatus(cnvmlDevice, cStatus) + __ret := C.dispatch_nvmlDeviceGetClkMonStatus(cnvmlDevice, cStatus) __v := (Return)(__ret) return __v } @@ -1770,7 +1769,7 @@ func nvmlDeviceGetProcessUtilization(nvmlDevice nvmlDevice, Utilization *Process cUtilization, _ := (*C.nvmlProcessUtilizationSample_t)(unsafe.Pointer(Utilization)), cgoAllocsUnknown cProcessSamplesCount, _ := (*C.uint)(unsafe.Pointer(ProcessSamplesCount)), cgoAllocsUnknown cLastSeenTimeStamp, _ := (C.ulonglong)(LastSeenTimeStamp), cgoAllocsUnknown - __ret := C.nvmlDeviceGetProcessUtilization(cnvmlDevice, cUtilization, cProcessSamplesCount, cLastSeenTimeStamp) + __ret := C.dispatch_nvmlDeviceGetProcessUtilization(cnvmlDevice, cUtilization, cProcessSamplesCount, cLastSeenTimeStamp) __v := (Return)(__ret) return __v } @@ -1779,7 +1778,7 @@ func nvmlDeviceGetProcessUtilization(nvmlDevice nvmlDevice, Utilization *Process func nvmlDeviceGetProcessesUtilizationInfo(nvmlDevice nvmlDevice, ProcesesUtilInfo *ProcessesUtilizationInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cProcesesUtilInfo, _ := (*C.nvmlProcessesUtilizationInfo_t)(unsafe.Pointer(ProcesesUtilInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetProcessesUtilizationInfo(cnvmlDevice, cProcesesUtilInfo) + __ret := C.dispatch_nvmlDeviceGetProcessesUtilizationInfo(cnvmlDevice, cProcesesUtilInfo) __v := (Return)(__ret) return __v } @@ -1788,7 +1787,7 @@ func nvmlDeviceGetProcessesUtilizationInfo(nvmlDevice nvmlDevice, ProcesesUtilIn func nvmlDeviceGetPlatformInfo(nvmlDevice nvmlDevice, PlatformInfo *PlatformInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPlatformInfo, _ := (*C.nvmlPlatformInfo_t)(unsafe.Pointer(PlatformInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPlatformInfo(cnvmlDevice, cPlatformInfo) + __ret := C.dispatch_nvmlDeviceGetPlatformInfo(cnvmlDevice, cPlatformInfo) __v := (Return)(__ret) return __v } @@ -1797,7 +1796,7 @@ func nvmlDeviceGetPlatformInfo(nvmlDevice nvmlDevice, PlatformInfo *PlatformInfo func nvmlDeviceGetPdi(nvmlDevice nvmlDevice, Pdi *Pdi) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPdi, _ := (*C.nvmlPdi_t)(unsafe.Pointer(Pdi)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPdi(cnvmlDevice, cPdi) + __ret := C.dispatch_nvmlDeviceGetPdi(cnvmlDevice, cPdi) __v := (Return)(__ret) return __v } @@ -1806,7 +1805,7 @@ func nvmlDeviceGetPdi(nvmlDevice nvmlDevice, Pdi *Pdi) Return { func nvmlUnitSetLedState(nvmlUnit nvmlUnit, Color LedColor) Return { cnvmlUnit, _ := *(*C.nvmlUnit_t)(unsafe.Pointer(&nvmlUnit)), cgoAllocsUnknown cColor, _ := (C.nvmlLedColor_t)(Color), cgoAllocsUnknown - __ret := C.nvmlUnitSetLedState(cnvmlUnit, cColor) + __ret := C.dispatch_nvmlUnitSetLedState(cnvmlUnit, cColor) __v := (Return)(__ret) return __v } @@ -1815,7 +1814,7 @@ func nvmlUnitSetLedState(nvmlUnit nvmlUnit, Color LedColor) Return { func nvmlDeviceSetPersistenceMode(nvmlDevice nvmlDevice, Mode EnableState) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMode, _ := (C.nvmlEnableState_t)(Mode), cgoAllocsUnknown - __ret := C.nvmlDeviceSetPersistenceMode(cnvmlDevice, cMode) + __ret := C.dispatch_nvmlDeviceSetPersistenceMode(cnvmlDevice, cMode) __v := (Return)(__ret) return __v } @@ -1824,7 +1823,7 @@ func nvmlDeviceSetPersistenceMode(nvmlDevice nvmlDevice, Mode EnableState) Retur func nvmlDeviceSetComputeMode(nvmlDevice nvmlDevice, Mode ComputeMode) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMode, _ := (C.nvmlComputeMode_t)(Mode), cgoAllocsUnknown - __ret := C.nvmlDeviceSetComputeMode(cnvmlDevice, cMode) + __ret := C.dispatch_nvmlDeviceSetComputeMode(cnvmlDevice, cMode) __v := (Return)(__ret) return __v } @@ -1833,7 +1832,7 @@ func nvmlDeviceSetComputeMode(nvmlDevice nvmlDevice, Mode ComputeMode) Return { func nvmlDeviceSetEccMode(nvmlDevice nvmlDevice, Ecc EnableState) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cEcc, _ := (C.nvmlEnableState_t)(Ecc), cgoAllocsUnknown - __ret := C.nvmlDeviceSetEccMode(cnvmlDevice, cEcc) + __ret := C.dispatch_nvmlDeviceSetEccMode(cnvmlDevice, cEcc) __v := (Return)(__ret) return __v } @@ -1842,7 +1841,7 @@ func nvmlDeviceSetEccMode(nvmlDevice nvmlDevice, Ecc EnableState) Return { func nvmlDeviceClearEccErrorCounts(nvmlDevice nvmlDevice, CounterType EccCounterType) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCounterType, _ := (C.nvmlEccCounterType_t)(CounterType), cgoAllocsUnknown - __ret := C.nvmlDeviceClearEccErrorCounts(cnvmlDevice, cCounterType) + __ret := C.dispatch_nvmlDeviceClearEccErrorCounts(cnvmlDevice, cCounterType) __v := (Return)(__ret) return __v } @@ -1852,7 +1851,7 @@ func nvmlDeviceSetDriverModel(nvmlDevice nvmlDevice, DriverModel DriverModel, Fl cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cDriverModel, _ := (C.nvmlDriverModel_t)(DriverModel), cgoAllocsUnknown cFlags, _ := (C.uint)(Flags), cgoAllocsUnknown - __ret := C.nvmlDeviceSetDriverModel(cnvmlDevice, cDriverModel, cFlags) + __ret := C.dispatch_nvmlDeviceSetDriverModel(cnvmlDevice, cDriverModel, cFlags) __v := (Return)(__ret) return __v } @@ -1862,7 +1861,7 @@ func nvmlDeviceSetGpuLockedClocks(nvmlDevice nvmlDevice, MinGpuClockMHz uint32, cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMinGpuClockMHz, _ := (C.uint)(MinGpuClockMHz), cgoAllocsUnknown cMaxGpuClockMHz, _ := (C.uint)(MaxGpuClockMHz), cgoAllocsUnknown - __ret := C.nvmlDeviceSetGpuLockedClocks(cnvmlDevice, cMinGpuClockMHz, cMaxGpuClockMHz) + __ret := C.dispatch_nvmlDeviceSetGpuLockedClocks(cnvmlDevice, cMinGpuClockMHz, cMaxGpuClockMHz) __v := (Return)(__ret) return __v } @@ -1870,7 +1869,7 @@ func nvmlDeviceSetGpuLockedClocks(nvmlDevice nvmlDevice, MinGpuClockMHz uint32, // nvmlDeviceResetGpuLockedClocks function as declared in nvml/nvml.h func nvmlDeviceResetGpuLockedClocks(nvmlDevice nvmlDevice) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceResetGpuLockedClocks(cnvmlDevice) + __ret := C.dispatch_nvmlDeviceResetGpuLockedClocks(cnvmlDevice) __v := (Return)(__ret) return __v } @@ -1880,7 +1879,7 @@ func nvmlDeviceSetMemoryLockedClocks(nvmlDevice nvmlDevice, MinMemClockMHz uint3 cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMinMemClockMHz, _ := (C.uint)(MinMemClockMHz), cgoAllocsUnknown cMaxMemClockMHz, _ := (C.uint)(MaxMemClockMHz), cgoAllocsUnknown - __ret := C.nvmlDeviceSetMemoryLockedClocks(cnvmlDevice, cMinMemClockMHz, cMaxMemClockMHz) + __ret := C.dispatch_nvmlDeviceSetMemoryLockedClocks(cnvmlDevice, cMinMemClockMHz, cMaxMemClockMHz) __v := (Return)(__ret) return __v } @@ -1888,7 +1887,7 @@ func nvmlDeviceSetMemoryLockedClocks(nvmlDevice nvmlDevice, MinMemClockMHz uint3 // nvmlDeviceResetMemoryLockedClocks function as declared in nvml/nvml.h func nvmlDeviceResetMemoryLockedClocks(nvmlDevice nvmlDevice) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceResetMemoryLockedClocks(cnvmlDevice) + __ret := C.dispatch_nvmlDeviceResetMemoryLockedClocks(cnvmlDevice) __v := (Return)(__ret) return __v } @@ -1898,7 +1897,7 @@ func nvmlDeviceSetApplicationsClocks(nvmlDevice nvmlDevice, MemClockMHz uint32, cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMemClockMHz, _ := (C.uint)(MemClockMHz), cgoAllocsUnknown cGraphicsClockMHz, _ := (C.uint)(GraphicsClockMHz), cgoAllocsUnknown - __ret := C.nvmlDeviceSetApplicationsClocks(cnvmlDevice, cMemClockMHz, cGraphicsClockMHz) + __ret := C.dispatch_nvmlDeviceSetApplicationsClocks(cnvmlDevice, cMemClockMHz, cGraphicsClockMHz) __v := (Return)(__ret) return __v } @@ -1906,7 +1905,7 @@ func nvmlDeviceSetApplicationsClocks(nvmlDevice nvmlDevice, MemClockMHz uint32, // nvmlDeviceResetApplicationsClocks function as declared in nvml/nvml.h func nvmlDeviceResetApplicationsClocks(nvmlDevice nvmlDevice) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceResetApplicationsClocks(cnvmlDevice) + __ret := C.dispatch_nvmlDeviceResetApplicationsClocks(cnvmlDevice) __v := (Return)(__ret) return __v } @@ -1915,7 +1914,7 @@ func nvmlDeviceResetApplicationsClocks(nvmlDevice nvmlDevice) Return { func nvmlDeviceSetAutoBoostedClocksEnabled(nvmlDevice nvmlDevice, Enabled EnableState) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cEnabled, _ := (C.nvmlEnableState_t)(Enabled), cgoAllocsUnknown - __ret := C.nvmlDeviceSetAutoBoostedClocksEnabled(cnvmlDevice, cEnabled) + __ret := C.dispatch_nvmlDeviceSetAutoBoostedClocksEnabled(cnvmlDevice, cEnabled) __v := (Return)(__ret) return __v } @@ -1925,7 +1924,7 @@ func nvmlDeviceSetDefaultAutoBoostedClocksEnabled(nvmlDevice nvmlDevice, Enabled cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cEnabled, _ := (C.nvmlEnableState_t)(Enabled), cgoAllocsUnknown cFlags, _ := (C.uint)(Flags), cgoAllocsUnknown - __ret := C.nvmlDeviceSetDefaultAutoBoostedClocksEnabled(cnvmlDevice, cEnabled, cFlags) + __ret := C.dispatch_nvmlDeviceSetDefaultAutoBoostedClocksEnabled(cnvmlDevice, cEnabled, cFlags) __v := (Return)(__ret) return __v } @@ -1934,7 +1933,7 @@ func nvmlDeviceSetDefaultAutoBoostedClocksEnabled(nvmlDevice nvmlDevice, Enabled func nvmlDeviceSetDefaultFanSpeed_v2(nvmlDevice nvmlDevice, Fan uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cFan, _ := (C.uint)(Fan), cgoAllocsUnknown - __ret := C.nvmlDeviceSetDefaultFanSpeed_v2(cnvmlDevice, cFan) + __ret := C.dispatch_nvmlDeviceSetDefaultFanSpeed_v2(cnvmlDevice, cFan) __v := (Return)(__ret) return __v } @@ -1944,7 +1943,7 @@ func nvmlDeviceSetFanControlPolicy(nvmlDevice nvmlDevice, Fan uint32, Policy Fan cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cFan, _ := (C.uint)(Fan), cgoAllocsUnknown cPolicy, _ := (C.nvmlFanControlPolicy_t)(Policy), cgoAllocsUnknown - __ret := C.nvmlDeviceSetFanControlPolicy(cnvmlDevice, cFan, cPolicy) + __ret := C.dispatch_nvmlDeviceSetFanControlPolicy(cnvmlDevice, cFan, cPolicy) __v := (Return)(__ret) return __v } @@ -1954,7 +1953,7 @@ func nvmlDeviceSetTemperatureThreshold(nvmlDevice nvmlDevice, ThresholdType Temp cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cThresholdType, _ := (C.nvmlTemperatureThresholds_t)(ThresholdType), cgoAllocsUnknown cTemp, _ := (*C.int)(unsafe.Pointer(Temp)), cgoAllocsUnknown - __ret := C.nvmlDeviceSetTemperatureThreshold(cnvmlDevice, cThresholdType, cTemp) + __ret := C.dispatch_nvmlDeviceSetTemperatureThreshold(cnvmlDevice, cThresholdType, cTemp) __v := (Return)(__ret) return __v } @@ -1963,7 +1962,7 @@ func nvmlDeviceSetTemperatureThreshold(nvmlDevice nvmlDevice, ThresholdType Temp func nvmlDeviceSetPowerManagementLimit(nvmlDevice nvmlDevice, Limit uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cLimit, _ := (C.uint)(Limit), cgoAllocsUnknown - __ret := C.nvmlDeviceSetPowerManagementLimit(cnvmlDevice, cLimit) + __ret := C.dispatch_nvmlDeviceSetPowerManagementLimit(cnvmlDevice, cLimit) __v := (Return)(__ret) return __v } @@ -1972,7 +1971,7 @@ func nvmlDeviceSetPowerManagementLimit(nvmlDevice nvmlDevice, Limit uint32) Retu func nvmlDeviceSetGpuOperationMode(nvmlDevice nvmlDevice, Mode GpuOperationMode) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMode, _ := (C.nvmlGpuOperationMode_t)(Mode), cgoAllocsUnknown - __ret := C.nvmlDeviceSetGpuOperationMode(cnvmlDevice, cMode) + __ret := C.dispatch_nvmlDeviceSetGpuOperationMode(cnvmlDevice, cMode) __v := (Return)(__ret) return __v } @@ -1982,7 +1981,7 @@ func nvmlDeviceSetAPIRestriction(nvmlDevice nvmlDevice, ApiType RestrictedAPI, I cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cApiType, _ := (C.nvmlRestrictedAPI_t)(ApiType), cgoAllocsUnknown cIsRestricted, _ := (C.nvmlEnableState_t)(IsRestricted), cgoAllocsUnknown - __ret := C.nvmlDeviceSetAPIRestriction(cnvmlDevice, cApiType, cIsRestricted) + __ret := C.dispatch_nvmlDeviceSetAPIRestriction(cnvmlDevice, cApiType, cIsRestricted) __v := (Return)(__ret) return __v } @@ -1992,7 +1991,7 @@ func nvmlDeviceSetFanSpeed_v2(nvmlDevice nvmlDevice, Fan uint32, Speed uint32) R cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cFan, _ := (C.uint)(Fan), cgoAllocsUnknown cSpeed, _ := (C.uint)(Speed), cgoAllocsUnknown - __ret := C.nvmlDeviceSetFanSpeed_v2(cnvmlDevice, cFan, cSpeed) + __ret := C.dispatch_nvmlDeviceSetFanSpeed_v2(cnvmlDevice, cFan, cSpeed) __v := (Return)(__ret) return __v } @@ -2001,7 +2000,7 @@ func nvmlDeviceSetFanSpeed_v2(nvmlDevice nvmlDevice, Fan uint32, Speed uint32) R func nvmlDeviceSetGpcClkVfOffset(nvmlDevice nvmlDevice, Offset int32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cOffset, _ := (C.int)(Offset), cgoAllocsUnknown - __ret := C.nvmlDeviceSetGpcClkVfOffset(cnvmlDevice, cOffset) + __ret := C.dispatch_nvmlDeviceSetGpcClkVfOffset(cnvmlDevice, cOffset) __v := (Return)(__ret) return __v } @@ -2010,7 +2009,7 @@ func nvmlDeviceSetGpcClkVfOffset(nvmlDevice nvmlDevice, Offset int32) Return { func nvmlDeviceSetMemClkVfOffset(nvmlDevice nvmlDevice, Offset int32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cOffset, _ := (C.int)(Offset), cgoAllocsUnknown - __ret := C.nvmlDeviceSetMemClkVfOffset(cnvmlDevice, cOffset) + __ret := C.dispatch_nvmlDeviceSetMemClkVfOffset(cnvmlDevice, cOffset) __v := (Return)(__ret) return __v } @@ -2019,7 +2018,7 @@ func nvmlDeviceSetMemClkVfOffset(nvmlDevice nvmlDevice, Offset int32) Return { func nvmlDeviceSetAccountingMode(nvmlDevice nvmlDevice, Mode EnableState) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMode, _ := (C.nvmlEnableState_t)(Mode), cgoAllocsUnknown - __ret := C.nvmlDeviceSetAccountingMode(cnvmlDevice, cMode) + __ret := C.dispatch_nvmlDeviceSetAccountingMode(cnvmlDevice, cMode) __v := (Return)(__ret) return __v } @@ -2027,7 +2026,7 @@ func nvmlDeviceSetAccountingMode(nvmlDevice nvmlDevice, Mode EnableState) Return // nvmlDeviceClearAccountingPids function as declared in nvml/nvml.h func nvmlDeviceClearAccountingPids(nvmlDevice nvmlDevice) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceClearAccountingPids(cnvmlDevice) + __ret := C.dispatch_nvmlDeviceClearAccountingPids(cnvmlDevice) __v := (Return)(__ret) return __v } @@ -2037,7 +2036,7 @@ func nvmlDeviceGetNvLinkState(nvmlDevice nvmlDevice, Link uint32, IsActive *Enab cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cLink, _ := (C.uint)(Link), cgoAllocsUnknown cIsActive, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(IsActive)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNvLinkState(cnvmlDevice, cLink, cIsActive) + __ret := C.dispatch_nvmlDeviceGetNvLinkState(cnvmlDevice, cLink, cIsActive) __v := (Return)(__ret) return __v } @@ -2047,7 +2046,7 @@ func nvmlDeviceGetNvLinkVersion(nvmlDevice nvmlDevice, Link uint32, Version *uin cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cLink, _ := (C.uint)(Link), cgoAllocsUnknown cVersion, _ := (*C.uint)(unsafe.Pointer(Version)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNvLinkVersion(cnvmlDevice, cLink, cVersion) + __ret := C.dispatch_nvmlDeviceGetNvLinkVersion(cnvmlDevice, cLink, cVersion) __v := (Return)(__ret) return __v } @@ -2058,7 +2057,7 @@ func nvmlDeviceGetNvLinkCapability(nvmlDevice nvmlDevice, Link uint32, Capabilit cLink, _ := (C.uint)(Link), cgoAllocsUnknown cCapability, _ := (C.nvmlNvLinkCapability_t)(Capability), cgoAllocsUnknown cCapResult, _ := (*C.uint)(unsafe.Pointer(CapResult)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNvLinkCapability(cnvmlDevice, cLink, cCapability, cCapResult) + __ret := C.dispatch_nvmlDeviceGetNvLinkCapability(cnvmlDevice, cLink, cCapability, cCapResult) __v := (Return)(__ret) return __v } @@ -2068,7 +2067,7 @@ func nvmlDeviceGetNvLinkRemotePciInfo_v2(nvmlDevice nvmlDevice, Link uint32, Pci cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cLink, _ := (C.uint)(Link), cgoAllocsUnknown cPci, _ := (*C.nvmlPciInfo_t)(unsafe.Pointer(Pci)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNvLinkRemotePciInfo_v2(cnvmlDevice, cLink, cPci) + __ret := C.dispatch_nvmlDeviceGetNvLinkRemotePciInfo_v2(cnvmlDevice, cLink, cPci) __v := (Return)(__ret) return __v } @@ -2079,7 +2078,7 @@ func nvmlDeviceGetNvLinkErrorCounter(nvmlDevice nvmlDevice, Link uint32, Counter cLink, _ := (C.uint)(Link), cgoAllocsUnknown cCounter, _ := (C.nvmlNvLinkErrorCounter_t)(Counter), cgoAllocsUnknown cCounterValue, _ := (*C.ulonglong)(unsafe.Pointer(CounterValue)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNvLinkErrorCounter(cnvmlDevice, cLink, cCounter, cCounterValue) + __ret := C.dispatch_nvmlDeviceGetNvLinkErrorCounter(cnvmlDevice, cLink, cCounter, cCounterValue) __v := (Return)(__ret) return __v } @@ -2088,7 +2087,7 @@ func nvmlDeviceGetNvLinkErrorCounter(nvmlDevice nvmlDevice, Link uint32, Counter func nvmlDeviceResetNvLinkErrorCounters(nvmlDevice nvmlDevice, Link uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cLink, _ := (C.uint)(Link), cgoAllocsUnknown - __ret := C.nvmlDeviceResetNvLinkErrorCounters(cnvmlDevice, cLink) + __ret := C.dispatch_nvmlDeviceResetNvLinkErrorCounters(cnvmlDevice, cLink) __v := (Return)(__ret) return __v } @@ -2100,7 +2099,7 @@ func nvmlDeviceSetNvLinkUtilizationControl(nvmlDevice nvmlDevice, Link uint32, C cCounter, _ := (C.uint)(Counter), cgoAllocsUnknown cControl, _ := (*C.nvmlNvLinkUtilizationControl_t)(unsafe.Pointer(Control)), cgoAllocsUnknown cReset, _ := (C.uint)(Reset), cgoAllocsUnknown - __ret := C.nvmlDeviceSetNvLinkUtilizationControl(cnvmlDevice, cLink, cCounter, cControl, cReset) + __ret := C.dispatch_nvmlDeviceSetNvLinkUtilizationControl(cnvmlDevice, cLink, cCounter, cControl, cReset) __v := (Return)(__ret) return __v } @@ -2111,7 +2110,7 @@ func nvmlDeviceGetNvLinkUtilizationControl(nvmlDevice nvmlDevice, Link uint32, C cLink, _ := (C.uint)(Link), cgoAllocsUnknown cCounter, _ := (C.uint)(Counter), cgoAllocsUnknown cControl, _ := (*C.nvmlNvLinkUtilizationControl_t)(unsafe.Pointer(Control)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNvLinkUtilizationControl(cnvmlDevice, cLink, cCounter, cControl) + __ret := C.dispatch_nvmlDeviceGetNvLinkUtilizationControl(cnvmlDevice, cLink, cCounter, cControl) __v := (Return)(__ret) return __v } @@ -2123,7 +2122,7 @@ func nvmlDeviceGetNvLinkUtilizationCounter(nvmlDevice nvmlDevice, Link uint32, C cCounter, _ := (C.uint)(Counter), cgoAllocsUnknown cRxcounter, _ := (*C.ulonglong)(unsafe.Pointer(Rxcounter)), cgoAllocsUnknown cTxcounter, _ := (*C.ulonglong)(unsafe.Pointer(Txcounter)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNvLinkUtilizationCounter(cnvmlDevice, cLink, cCounter, cRxcounter, cTxcounter) + __ret := C.dispatch_nvmlDeviceGetNvLinkUtilizationCounter(cnvmlDevice, cLink, cCounter, cRxcounter, cTxcounter) __v := (Return)(__ret) return __v } @@ -2134,7 +2133,7 @@ func nvmlDeviceFreezeNvLinkUtilizationCounter(nvmlDevice nvmlDevice, Link uint32 cLink, _ := (C.uint)(Link), cgoAllocsUnknown cCounter, _ := (C.uint)(Counter), cgoAllocsUnknown cFreeze, _ := (C.nvmlEnableState_t)(Freeze), cgoAllocsUnknown - __ret := C.nvmlDeviceFreezeNvLinkUtilizationCounter(cnvmlDevice, cLink, cCounter, cFreeze) + __ret := C.dispatch_nvmlDeviceFreezeNvLinkUtilizationCounter(cnvmlDevice, cLink, cCounter, cFreeze) __v := (Return)(__ret) return __v } @@ -2144,7 +2143,7 @@ func nvmlDeviceResetNvLinkUtilizationCounter(nvmlDevice nvmlDevice, Link uint32, cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cLink, _ := (C.uint)(Link), cgoAllocsUnknown cCounter, _ := (C.uint)(Counter), cgoAllocsUnknown - __ret := C.nvmlDeviceResetNvLinkUtilizationCounter(cnvmlDevice, cLink, cCounter) + __ret := C.dispatch_nvmlDeviceResetNvLinkUtilizationCounter(cnvmlDevice, cLink, cCounter) __v := (Return)(__ret) return __v } @@ -2154,7 +2153,7 @@ func nvmlDeviceGetNvLinkRemoteDeviceType(nvmlDevice nvmlDevice, Link uint32, PNv cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cLink, _ := (C.uint)(Link), cgoAllocsUnknown cPNvLinkDeviceType, _ := (*C.nvmlIntNvLinkDeviceType_t)(unsafe.Pointer(PNvLinkDeviceType)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNvLinkRemoteDeviceType(cnvmlDevice, cLink, cPNvLinkDeviceType) + __ret := C.dispatch_nvmlDeviceGetNvLinkRemoteDeviceType(cnvmlDevice, cLink, cPNvLinkDeviceType) __v := (Return)(__ret) return __v } @@ -2163,7 +2162,7 @@ func nvmlDeviceGetNvLinkRemoteDeviceType(nvmlDevice nvmlDevice, Link uint32, PNv func nvmlDeviceSetNvLinkDeviceLowPowerThreshold(nvmlDevice nvmlDevice, Info *NvLinkPowerThres) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cInfo, _ := (*C.nvmlNvLinkPowerThres_t)(unsafe.Pointer(Info)), cgoAllocsUnknown - __ret := C.nvmlDeviceSetNvLinkDeviceLowPowerThreshold(cnvmlDevice, cInfo) + __ret := C.dispatch_nvmlDeviceSetNvLinkDeviceLowPowerThreshold(cnvmlDevice, cInfo) __v := (Return)(__ret) return __v } @@ -2171,7 +2170,7 @@ func nvmlDeviceSetNvLinkDeviceLowPowerThreshold(nvmlDevice nvmlDevice, Info *NvL // nvmlSystemSetNvlinkBwMode function as declared in nvml/nvml.h func nvmlSystemSetNvlinkBwMode(NvlinkBwMode uint32) Return { cNvlinkBwMode, _ := (C.uint)(NvlinkBwMode), cgoAllocsUnknown - __ret := C.nvmlSystemSetNvlinkBwMode(cNvlinkBwMode) + __ret := C.dispatch_nvmlSystemSetNvlinkBwMode(cNvlinkBwMode) __v := (Return)(__ret) return __v } @@ -2179,7 +2178,7 @@ func nvmlSystemSetNvlinkBwMode(NvlinkBwMode uint32) Return { // nvmlSystemGetNvlinkBwMode function as declared in nvml/nvml.h func nvmlSystemGetNvlinkBwMode(NvlinkBwMode *uint32) Return { cNvlinkBwMode, _ := (*C.uint)(unsafe.Pointer(NvlinkBwMode)), cgoAllocsUnknown - __ret := C.nvmlSystemGetNvlinkBwMode(cNvlinkBwMode) + __ret := C.dispatch_nvmlSystemGetNvlinkBwMode(cNvlinkBwMode) __v := (Return)(__ret) return __v } @@ -2188,7 +2187,7 @@ func nvmlSystemGetNvlinkBwMode(NvlinkBwMode *uint32) Return { func nvmlDeviceGetNvlinkSupportedBwModes(nvmlDevice nvmlDevice, SupportedBwMode *NvlinkSupportedBwModes) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cSupportedBwMode, _ := (*C.nvmlNvlinkSupportedBwModes_t)(unsafe.Pointer(SupportedBwMode)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNvlinkSupportedBwModes(cnvmlDevice, cSupportedBwMode) + __ret := C.dispatch_nvmlDeviceGetNvlinkSupportedBwModes(cnvmlDevice, cSupportedBwMode) __v := (Return)(__ret) return __v } @@ -2197,7 +2196,7 @@ func nvmlDeviceGetNvlinkSupportedBwModes(nvmlDevice nvmlDevice, SupportedBwMode func nvmlDeviceGetNvlinkBwMode(nvmlDevice nvmlDevice, GetBwMode *NvlinkGetBwMode) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cGetBwMode, _ := (*C.nvmlNvlinkGetBwMode_t)(unsafe.Pointer(GetBwMode)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNvlinkBwMode(cnvmlDevice, cGetBwMode) + __ret := C.dispatch_nvmlDeviceGetNvlinkBwMode(cnvmlDevice, cGetBwMode) __v := (Return)(__ret) return __v } @@ -2206,7 +2205,7 @@ func nvmlDeviceGetNvlinkBwMode(nvmlDevice nvmlDevice, GetBwMode *NvlinkGetBwMode func nvmlDeviceSetNvlinkBwMode(nvmlDevice nvmlDevice, SetBwMode *NvlinkSetBwMode) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cSetBwMode, _ := (*C.nvmlNvlinkSetBwMode_t)(unsafe.Pointer(SetBwMode)), cgoAllocsUnknown - __ret := C.nvmlDeviceSetNvlinkBwMode(cnvmlDevice, cSetBwMode) + __ret := C.dispatch_nvmlDeviceSetNvlinkBwMode(cnvmlDevice, cSetBwMode) __v := (Return)(__ret) return __v } @@ -2215,7 +2214,7 @@ func nvmlDeviceSetNvlinkBwMode(nvmlDevice nvmlDevice, SetBwMode *NvlinkSetBwMode func nvmlDeviceGetNvLinkInfo(nvmlDevice nvmlDevice, Info *NvLinkInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cInfo, _ := (*C.nvmlNvLinkInfo_t)(unsafe.Pointer(Info)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNvLinkInfo(cnvmlDevice, cInfo) + __ret := C.dispatch_nvmlDeviceGetNvLinkInfo(cnvmlDevice, cInfo) __v := (Return)(__ret) return __v } @@ -2223,7 +2222,7 @@ func nvmlDeviceGetNvLinkInfo(nvmlDevice nvmlDevice, Info *NvLinkInfo) Return { // nvmlEventSetCreate function as declared in nvml/nvml.h func nvmlEventSetCreate(Set *nvmlEventSet) Return { cSet, _ := (*C.nvmlEventSet_t)(unsafe.Pointer(Set)), cgoAllocsUnknown - __ret := C.nvmlEventSetCreate(cSet) + __ret := C.dispatch_nvmlEventSetCreate(cSet) __v := (Return)(__ret) return __v } @@ -2233,7 +2232,7 @@ func nvmlDeviceRegisterEvents(nvmlDevice nvmlDevice, EventTypes uint64, Set nvml cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cEventTypes, _ := (C.ulonglong)(EventTypes), cgoAllocsUnknown cSet, _ := *(*C.nvmlEventSet_t)(unsafe.Pointer(&Set)), cgoAllocsUnknown - __ret := C.nvmlDeviceRegisterEvents(cnvmlDevice, cEventTypes, cSet) + __ret := C.dispatch_nvmlDeviceRegisterEvents(cnvmlDevice, cEventTypes, cSet) __v := (Return)(__ret) return __v } @@ -2242,7 +2241,7 @@ func nvmlDeviceRegisterEvents(nvmlDevice nvmlDevice, EventTypes uint64, Set nvml func nvmlDeviceGetSupportedEventTypes(nvmlDevice nvmlDevice, EventTypes *uint64) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cEventTypes, _ := (*C.ulonglong)(unsafe.Pointer(EventTypes)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetSupportedEventTypes(cnvmlDevice, cEventTypes) + __ret := C.dispatch_nvmlDeviceGetSupportedEventTypes(cnvmlDevice, cEventTypes) __v := (Return)(__ret) return __v } @@ -2252,7 +2251,7 @@ func nvmlEventSetWait_v2(Set nvmlEventSet, Data *nvmlEventData, Timeoutms uint32 cSet, _ := *(*C.nvmlEventSet_t)(unsafe.Pointer(&Set)), cgoAllocsUnknown cData, _ := (*C.nvmlEventData_t)(unsafe.Pointer(Data)), cgoAllocsUnknown cTimeoutms, _ := (C.uint)(Timeoutms), cgoAllocsUnknown - __ret := C.nvmlEventSetWait_v2(cSet, cData, cTimeoutms) + __ret := C.dispatch_nvmlEventSetWait_v2(cSet, cData, cTimeoutms) __v := (Return)(__ret) return __v } @@ -2260,7 +2259,7 @@ func nvmlEventSetWait_v2(Set nvmlEventSet, Data *nvmlEventData, Timeoutms uint32 // nvmlEventSetFree function as declared in nvml/nvml.h func nvmlEventSetFree(Set nvmlEventSet) Return { cSet, _ := *(*C.nvmlEventSet_t)(unsafe.Pointer(&Set)), cgoAllocsUnknown - __ret := C.nvmlEventSetFree(cSet) + __ret := C.dispatch_nvmlEventSetFree(cSet) __v := (Return)(__ret) return __v } @@ -2268,7 +2267,7 @@ func nvmlEventSetFree(Set nvmlEventSet) Return { // nvmlSystemEventSetCreate function as declared in nvml/nvml.h func nvmlSystemEventSetCreate(Request *SystemEventSetCreateRequest) Return { cRequest, _ := (*C.nvmlSystemEventSetCreateRequest_t)(unsafe.Pointer(Request)), cgoAllocsUnknown - __ret := C.nvmlSystemEventSetCreate(cRequest) + __ret := C.dispatch_nvmlSystemEventSetCreate(cRequest) __v := (Return)(__ret) return __v } @@ -2276,7 +2275,7 @@ func nvmlSystemEventSetCreate(Request *SystemEventSetCreateRequest) Return { // nvmlSystemEventSetFree function as declared in nvml/nvml.h func nvmlSystemEventSetFree(Request *SystemEventSetFreeRequest) Return { cRequest, _ := (*C.nvmlSystemEventSetFreeRequest_t)(unsafe.Pointer(Request)), cgoAllocsUnknown - __ret := C.nvmlSystemEventSetFree(cRequest) + __ret := C.dispatch_nvmlSystemEventSetFree(cRequest) __v := (Return)(__ret) return __v } @@ -2284,7 +2283,7 @@ func nvmlSystemEventSetFree(Request *SystemEventSetFreeRequest) Return { // nvmlSystemRegisterEvents function as declared in nvml/nvml.h func nvmlSystemRegisterEvents(Request *SystemRegisterEventRequest) Return { cRequest, _ := (*C.nvmlSystemRegisterEventRequest_t)(unsafe.Pointer(Request)), cgoAllocsUnknown - __ret := C.nvmlSystemRegisterEvents(cRequest) + __ret := C.dispatch_nvmlSystemRegisterEvents(cRequest) __v := (Return)(__ret) return __v } @@ -2292,7 +2291,7 @@ func nvmlSystemRegisterEvents(Request *SystemRegisterEventRequest) Return { // nvmlSystemEventSetWait function as declared in nvml/nvml.h func nvmlSystemEventSetWait(Request *SystemEventSetWaitRequest) Return { cRequest, _ := (*C.nvmlSystemEventSetWaitRequest_t)(unsafe.Pointer(Request)), cgoAllocsUnknown - __ret := C.nvmlSystemEventSetWait(cRequest) + __ret := C.dispatch_nvmlSystemEventSetWait(cRequest) __v := (Return)(__ret) return __v } @@ -2301,7 +2300,7 @@ func nvmlSystemEventSetWait(Request *SystemEventSetWaitRequest) Return { func nvmlDeviceModifyDrainState(PciInfo *PciInfo, NewState EnableState) Return { cPciInfo, _ := (*C.nvmlPciInfo_t)(unsafe.Pointer(PciInfo)), cgoAllocsUnknown cNewState, _ := (C.nvmlEnableState_t)(NewState), cgoAllocsUnknown - __ret := C.nvmlDeviceModifyDrainState(cPciInfo, cNewState) + __ret := C.dispatch_nvmlDeviceModifyDrainState(cPciInfo, cNewState) __v := (Return)(__ret) return __v } @@ -2310,7 +2309,7 @@ func nvmlDeviceModifyDrainState(PciInfo *PciInfo, NewState EnableState) Return { func nvmlDeviceQueryDrainState(PciInfo *PciInfo, CurrentState *EnableState) Return { cPciInfo, _ := (*C.nvmlPciInfo_t)(unsafe.Pointer(PciInfo)), cgoAllocsUnknown cCurrentState, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(CurrentState)), cgoAllocsUnknown - __ret := C.nvmlDeviceQueryDrainState(cPciInfo, cCurrentState) + __ret := C.dispatch_nvmlDeviceQueryDrainState(cPciInfo, cCurrentState) __v := (Return)(__ret) return __v } @@ -2320,7 +2319,7 @@ func nvmlDeviceRemoveGpu_v2(PciInfo *PciInfo, GpuState DetachGpuState, LinkState cPciInfo, _ := (*C.nvmlPciInfo_t)(unsafe.Pointer(PciInfo)), cgoAllocsUnknown cGpuState, _ := (C.nvmlDetachGpuState_t)(GpuState), cgoAllocsUnknown cLinkState, _ := (C.nvmlPcieLinkState_t)(LinkState), cgoAllocsUnknown - __ret := C.nvmlDeviceRemoveGpu_v2(cPciInfo, cGpuState, cLinkState) + __ret := C.dispatch_nvmlDeviceRemoveGpu_v2(cPciInfo, cGpuState, cLinkState) __v := (Return)(__ret) return __v } @@ -2328,7 +2327,7 @@ func nvmlDeviceRemoveGpu_v2(PciInfo *PciInfo, GpuState DetachGpuState, LinkState // nvmlDeviceDiscoverGpus function as declared in nvml/nvml.h func nvmlDeviceDiscoverGpus(PciInfo *PciInfo) Return { cPciInfo, _ := (*C.nvmlPciInfo_t)(unsafe.Pointer(PciInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceDiscoverGpus(cPciInfo) + __ret := C.dispatch_nvmlDeviceDiscoverGpus(cPciInfo) __v := (Return)(__ret) return __v } @@ -2338,7 +2337,7 @@ func nvmlDeviceGetFieldValues(nvmlDevice nvmlDevice, ValuesCount int32, Values * cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cValuesCount, _ := (C.int)(ValuesCount), cgoAllocsUnknown cValues, _ := (*C.nvmlFieldValue_t)(unsafe.Pointer(Values)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetFieldValues(cnvmlDevice, cValuesCount, cValues) + __ret := C.dispatch_nvmlDeviceGetFieldValues(cnvmlDevice, cValuesCount, cValues) __v := (Return)(__ret) return __v } @@ -2348,7 +2347,7 @@ func nvmlDeviceClearFieldValues(nvmlDevice nvmlDevice, ValuesCount int32, Values cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cValuesCount, _ := (C.int)(ValuesCount), cgoAllocsUnknown cValues, _ := (*C.nvmlFieldValue_t)(unsafe.Pointer(Values)), cgoAllocsUnknown - __ret := C.nvmlDeviceClearFieldValues(cnvmlDevice, cValuesCount, cValues) + __ret := C.dispatch_nvmlDeviceClearFieldValues(cnvmlDevice, cValuesCount, cValues) __v := (Return)(__ret) return __v } @@ -2357,7 +2356,7 @@ func nvmlDeviceClearFieldValues(nvmlDevice nvmlDevice, ValuesCount int32, Values func nvmlDeviceGetVirtualizationMode(nvmlDevice nvmlDevice, PVirtualMode *GpuVirtualizationMode) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPVirtualMode, _ := (*C.nvmlGpuVirtualizationMode_t)(unsafe.Pointer(PVirtualMode)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetVirtualizationMode(cnvmlDevice, cPVirtualMode) + __ret := C.dispatch_nvmlDeviceGetVirtualizationMode(cnvmlDevice, cPVirtualMode) __v := (Return)(__ret) return __v } @@ -2366,7 +2365,7 @@ func nvmlDeviceGetVirtualizationMode(nvmlDevice nvmlDevice, PVirtualMode *GpuVir func nvmlDeviceGetHostVgpuMode(nvmlDevice nvmlDevice, PHostVgpuMode *HostVgpuMode) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPHostVgpuMode, _ := (*C.nvmlHostVgpuMode_t)(unsafe.Pointer(PHostVgpuMode)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetHostVgpuMode(cnvmlDevice, cPHostVgpuMode) + __ret := C.dispatch_nvmlDeviceGetHostVgpuMode(cnvmlDevice, cPHostVgpuMode) __v := (Return)(__ret) return __v } @@ -2375,7 +2374,7 @@ func nvmlDeviceGetHostVgpuMode(nvmlDevice nvmlDevice, PHostVgpuMode *HostVgpuMod func nvmlDeviceSetVirtualizationMode(nvmlDevice nvmlDevice, VirtualMode GpuVirtualizationMode) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cVirtualMode, _ := (C.nvmlGpuVirtualizationMode_t)(VirtualMode), cgoAllocsUnknown - __ret := C.nvmlDeviceSetVirtualizationMode(cnvmlDevice, cVirtualMode) + __ret := C.dispatch_nvmlDeviceSetVirtualizationMode(cnvmlDevice, cVirtualMode) __v := (Return)(__ret) return __v } @@ -2384,7 +2383,7 @@ func nvmlDeviceSetVirtualizationMode(nvmlDevice nvmlDevice, VirtualMode GpuVirtu func nvmlDeviceGetVgpuHeterogeneousMode(nvmlDevice nvmlDevice, PHeterogeneousMode *VgpuHeterogeneousMode) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPHeterogeneousMode, _ := (*C.nvmlVgpuHeterogeneousMode_t)(unsafe.Pointer(PHeterogeneousMode)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetVgpuHeterogeneousMode(cnvmlDevice, cPHeterogeneousMode) + __ret := C.dispatch_nvmlDeviceGetVgpuHeterogeneousMode(cnvmlDevice, cPHeterogeneousMode) __v := (Return)(__ret) return __v } @@ -2393,7 +2392,7 @@ func nvmlDeviceGetVgpuHeterogeneousMode(nvmlDevice nvmlDevice, PHeterogeneousMod func nvmlDeviceSetVgpuHeterogeneousMode(nvmlDevice nvmlDevice, PHeterogeneousMode *VgpuHeterogeneousMode) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPHeterogeneousMode, _ := (*C.nvmlVgpuHeterogeneousMode_t)(unsafe.Pointer(PHeterogeneousMode)), cgoAllocsUnknown - __ret := C.nvmlDeviceSetVgpuHeterogeneousMode(cnvmlDevice, cPHeterogeneousMode) + __ret := C.dispatch_nvmlDeviceSetVgpuHeterogeneousMode(cnvmlDevice, cPHeterogeneousMode) __v := (Return)(__ret) return __v } @@ -2402,7 +2401,7 @@ func nvmlDeviceSetVgpuHeterogeneousMode(nvmlDevice nvmlDevice, PHeterogeneousMod func nvmlVgpuInstanceGetPlacementId(nvmlVgpuInstance nvmlVgpuInstance, PPlacement *VgpuPlacementId) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cPPlacement, _ := (*C.nvmlVgpuPlacementId_t)(unsafe.Pointer(PPlacement)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetPlacementId(cnvmlVgpuInstance, cPPlacement) + __ret := C.dispatch_nvmlVgpuInstanceGetPlacementId(cnvmlVgpuInstance, cPPlacement) __v := (Return)(__ret) return __v } @@ -2412,7 +2411,7 @@ func nvmlDeviceGetVgpuTypeSupportedPlacements(nvmlDevice nvmlDevice, nvmlVgpuTyp cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cPPlacementList, _ := (*C.nvmlVgpuPlacementList_t)(unsafe.Pointer(PPlacementList)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetVgpuTypeSupportedPlacements(cnvmlDevice, cnvmlVgpuTypeId, cPPlacementList) + __ret := C.dispatch_nvmlDeviceGetVgpuTypeSupportedPlacements(cnvmlDevice, cnvmlVgpuTypeId, cPPlacementList) __v := (Return)(__ret) return __v } @@ -2422,7 +2421,7 @@ func nvmlDeviceGetVgpuTypeCreatablePlacements(nvmlDevice nvmlDevice, nvmlVgpuTyp cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cPPlacementList, _ := (*C.nvmlVgpuPlacementList_t)(unsafe.Pointer(PPlacementList)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetVgpuTypeCreatablePlacements(cnvmlDevice, cnvmlVgpuTypeId, cPPlacementList) + __ret := C.dispatch_nvmlDeviceGetVgpuTypeCreatablePlacements(cnvmlDevice, cnvmlVgpuTypeId, cPPlacementList) __v := (Return)(__ret) return __v } @@ -2431,7 +2430,7 @@ func nvmlDeviceGetVgpuTypeCreatablePlacements(nvmlDevice nvmlDevice, nvmlVgpuTyp func nvmlVgpuTypeGetGspHeapSize(nvmlVgpuTypeId nvmlVgpuTypeId, GspHeapSize *uint64) Return { cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cGspHeapSize, _ := (*C.ulonglong)(unsafe.Pointer(GspHeapSize)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetGspHeapSize(cnvmlVgpuTypeId, cGspHeapSize) + __ret := C.dispatch_nvmlVgpuTypeGetGspHeapSize(cnvmlVgpuTypeId, cGspHeapSize) __v := (Return)(__ret) return __v } @@ -2440,7 +2439,7 @@ func nvmlVgpuTypeGetGspHeapSize(nvmlVgpuTypeId nvmlVgpuTypeId, GspHeapSize *uint func nvmlVgpuTypeGetFbReservation(nvmlVgpuTypeId nvmlVgpuTypeId, FbReservation *uint64) Return { cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cFbReservation, _ := (*C.ulonglong)(unsafe.Pointer(FbReservation)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetFbReservation(cnvmlVgpuTypeId, cFbReservation) + __ret := C.dispatch_nvmlVgpuTypeGetFbReservation(cnvmlVgpuTypeId, cFbReservation) __v := (Return)(__ret) return __v } @@ -2449,7 +2448,7 @@ func nvmlVgpuTypeGetFbReservation(nvmlVgpuTypeId nvmlVgpuTypeId, FbReservation * func nvmlVgpuInstanceGetRuntimeStateSize(nvmlVgpuInstance nvmlVgpuInstance, PState *VgpuRuntimeState) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cPState, _ := (*C.nvmlVgpuRuntimeState_t)(unsafe.Pointer(PState)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetRuntimeStateSize(cnvmlVgpuInstance, cPState) + __ret := C.dispatch_nvmlVgpuInstanceGetRuntimeStateSize(cnvmlVgpuInstance, cPState) __v := (Return)(__ret) return __v } @@ -2459,7 +2458,7 @@ func nvmlDeviceSetVgpuCapabilities(nvmlDevice nvmlDevice, Capability DeviceVgpuC cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCapability, _ := (C.nvmlDeviceVgpuCapability_t)(Capability), cgoAllocsUnknown cState, _ := (C.nvmlEnableState_t)(State), cgoAllocsUnknown - __ret := C.nvmlDeviceSetVgpuCapabilities(cnvmlDevice, cCapability, cState) + __ret := C.dispatch_nvmlDeviceSetVgpuCapabilities(cnvmlDevice, cCapability, cState) __v := (Return)(__ret) return __v } @@ -2468,7 +2467,7 @@ func nvmlDeviceSetVgpuCapabilities(nvmlDevice nvmlDevice, Capability DeviceVgpuC func nvmlDeviceGetGridLicensableFeatures_v4(nvmlDevice nvmlDevice, PGridLicensableFeatures *GridLicensableFeatures) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPGridLicensableFeatures, _ := (*C.nvmlGridLicensableFeatures_t)(unsafe.Pointer(PGridLicensableFeatures)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGridLicensableFeatures_v4(cnvmlDevice, cPGridLicensableFeatures) + __ret := C.dispatch_nvmlDeviceGetGridLicensableFeatures_v4(cnvmlDevice, cPGridLicensableFeatures) __v := (Return)(__ret) return __v } @@ -2477,7 +2476,7 @@ func nvmlDeviceGetGridLicensableFeatures_v4(nvmlDevice nvmlDevice, PGridLicensab func nvmlGetVgpuDriverCapabilities(Capability VgpuDriverCapability, CapResult *uint32) Return { cCapability, _ := (C.nvmlVgpuDriverCapability_t)(Capability), cgoAllocsUnknown cCapResult, _ := (*C.uint)(unsafe.Pointer(CapResult)), cgoAllocsUnknown - __ret := C.nvmlGetVgpuDriverCapabilities(cCapability, cCapResult) + __ret := C.dispatch_nvmlGetVgpuDriverCapabilities(cCapability, cCapResult) __v := (Return)(__ret) return __v } @@ -2487,7 +2486,7 @@ func nvmlDeviceGetVgpuCapabilities(nvmlDevice nvmlDevice, Capability DeviceVgpuC cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCapability, _ := (C.nvmlDeviceVgpuCapability_t)(Capability), cgoAllocsUnknown cCapResult, _ := (*C.uint)(unsafe.Pointer(CapResult)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetVgpuCapabilities(cnvmlDevice, cCapability, cCapResult) + __ret := C.dispatch_nvmlDeviceGetVgpuCapabilities(cnvmlDevice, cCapability, cCapResult) __v := (Return)(__ret) return __v } @@ -2497,7 +2496,7 @@ func nvmlDeviceGetSupportedVgpus(nvmlDevice nvmlDevice, VgpuCount *uint32, VgpuT cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cVgpuCount, _ := (*C.uint)(unsafe.Pointer(VgpuCount)), cgoAllocsUnknown cVgpuTypeIds, _ := (*C.nvmlVgpuTypeId_t)(unsafe.Pointer(VgpuTypeIds)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetSupportedVgpus(cnvmlDevice, cVgpuCount, cVgpuTypeIds) + __ret := C.dispatch_nvmlDeviceGetSupportedVgpus(cnvmlDevice, cVgpuCount, cVgpuTypeIds) __v := (Return)(__ret) return __v } @@ -2507,7 +2506,7 @@ func nvmlDeviceGetCreatableVgpus(nvmlDevice nvmlDevice, VgpuCount *uint32, VgpuT cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cVgpuCount, _ := (*C.uint)(unsafe.Pointer(VgpuCount)), cgoAllocsUnknown cVgpuTypeIds, _ := (*C.nvmlVgpuTypeId_t)(unsafe.Pointer(VgpuTypeIds)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetCreatableVgpus(cnvmlDevice, cVgpuCount, cVgpuTypeIds) + __ret := C.dispatch_nvmlDeviceGetCreatableVgpus(cnvmlDevice, cVgpuCount, cVgpuTypeIds) __v := (Return)(__ret) return __v } @@ -2517,7 +2516,7 @@ func nvmlVgpuTypeGetClass(nvmlVgpuTypeId nvmlVgpuTypeId, VgpuTypeClass *byte, Si cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cVgpuTypeClass, _ := (*C.char)(unsafe.Pointer(VgpuTypeClass)), cgoAllocsUnknown cSize, _ := (*C.uint)(unsafe.Pointer(Size)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetClass(cnvmlVgpuTypeId, cVgpuTypeClass, cSize) + __ret := C.dispatch_nvmlVgpuTypeGetClass(cnvmlVgpuTypeId, cVgpuTypeClass, cSize) __v := (Return)(__ret) return __v } @@ -2527,7 +2526,7 @@ func nvmlVgpuTypeGetName(nvmlVgpuTypeId nvmlVgpuTypeId, VgpuTypeName *byte, Size cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cVgpuTypeName, _ := (*C.char)(unsafe.Pointer(VgpuTypeName)), cgoAllocsUnknown cSize, _ := (*C.uint)(unsafe.Pointer(Size)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetName(cnvmlVgpuTypeId, cVgpuTypeName, cSize) + __ret := C.dispatch_nvmlVgpuTypeGetName(cnvmlVgpuTypeId, cVgpuTypeName, cSize) __v := (Return)(__ret) return __v } @@ -2536,7 +2535,7 @@ func nvmlVgpuTypeGetName(nvmlVgpuTypeId nvmlVgpuTypeId, VgpuTypeName *byte, Size func nvmlVgpuTypeGetGpuInstanceProfileId(nvmlVgpuTypeId nvmlVgpuTypeId, GpuInstanceProfileId *uint32) Return { cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cGpuInstanceProfileId, _ := (*C.uint)(unsafe.Pointer(GpuInstanceProfileId)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetGpuInstanceProfileId(cnvmlVgpuTypeId, cGpuInstanceProfileId) + __ret := C.dispatch_nvmlVgpuTypeGetGpuInstanceProfileId(cnvmlVgpuTypeId, cGpuInstanceProfileId) __v := (Return)(__ret) return __v } @@ -2546,7 +2545,7 @@ func nvmlVgpuTypeGetDeviceID(nvmlVgpuTypeId nvmlVgpuTypeId, DeviceID *uint64, Su cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cDeviceID, _ := (*C.ulonglong)(unsafe.Pointer(DeviceID)), cgoAllocsUnknown cSubsystemID, _ := (*C.ulonglong)(unsafe.Pointer(SubsystemID)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetDeviceID(cnvmlVgpuTypeId, cDeviceID, cSubsystemID) + __ret := C.dispatch_nvmlVgpuTypeGetDeviceID(cnvmlVgpuTypeId, cDeviceID, cSubsystemID) __v := (Return)(__ret) return __v } @@ -2555,7 +2554,7 @@ func nvmlVgpuTypeGetDeviceID(nvmlVgpuTypeId nvmlVgpuTypeId, DeviceID *uint64, Su func nvmlVgpuTypeGetFramebufferSize(nvmlVgpuTypeId nvmlVgpuTypeId, FbSize *uint64) Return { cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cFbSize, _ := (*C.ulonglong)(unsafe.Pointer(FbSize)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetFramebufferSize(cnvmlVgpuTypeId, cFbSize) + __ret := C.dispatch_nvmlVgpuTypeGetFramebufferSize(cnvmlVgpuTypeId, cFbSize) __v := (Return)(__ret) return __v } @@ -2564,7 +2563,7 @@ func nvmlVgpuTypeGetFramebufferSize(nvmlVgpuTypeId nvmlVgpuTypeId, FbSize *uint6 func nvmlVgpuTypeGetNumDisplayHeads(nvmlVgpuTypeId nvmlVgpuTypeId, NumDisplayHeads *uint32) Return { cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cNumDisplayHeads, _ := (*C.uint)(unsafe.Pointer(NumDisplayHeads)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetNumDisplayHeads(cnvmlVgpuTypeId, cNumDisplayHeads) + __ret := C.dispatch_nvmlVgpuTypeGetNumDisplayHeads(cnvmlVgpuTypeId, cNumDisplayHeads) __v := (Return)(__ret) return __v } @@ -2575,7 +2574,7 @@ func nvmlVgpuTypeGetResolution(nvmlVgpuTypeId nvmlVgpuTypeId, DisplayIndex uint3 cDisplayIndex, _ := (C.uint)(DisplayIndex), cgoAllocsUnknown cXdim, _ := (*C.uint)(unsafe.Pointer(Xdim)), cgoAllocsUnknown cYdim, _ := (*C.uint)(unsafe.Pointer(Ydim)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetResolution(cnvmlVgpuTypeId, cDisplayIndex, cXdim, cYdim) + __ret := C.dispatch_nvmlVgpuTypeGetResolution(cnvmlVgpuTypeId, cDisplayIndex, cXdim, cYdim) __v := (Return)(__ret) return __v } @@ -2585,7 +2584,7 @@ func nvmlVgpuTypeGetLicense(nvmlVgpuTypeId nvmlVgpuTypeId, VgpuTypeLicenseString cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cVgpuTypeLicenseString, _ := (*C.char)(unsafe.Pointer(VgpuTypeLicenseString)), cgoAllocsUnknown cSize, _ := (C.uint)(Size), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetLicense(cnvmlVgpuTypeId, cVgpuTypeLicenseString, cSize) + __ret := C.dispatch_nvmlVgpuTypeGetLicense(cnvmlVgpuTypeId, cVgpuTypeLicenseString, cSize) __v := (Return)(__ret) return __v } @@ -2594,7 +2593,7 @@ func nvmlVgpuTypeGetLicense(nvmlVgpuTypeId nvmlVgpuTypeId, VgpuTypeLicenseString func nvmlVgpuTypeGetFrameRateLimit(nvmlVgpuTypeId nvmlVgpuTypeId, FrameRateLimit *uint32) Return { cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cFrameRateLimit, _ := (*C.uint)(unsafe.Pointer(FrameRateLimit)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetFrameRateLimit(cnvmlVgpuTypeId, cFrameRateLimit) + __ret := C.dispatch_nvmlVgpuTypeGetFrameRateLimit(cnvmlVgpuTypeId, cFrameRateLimit) __v := (Return)(__ret) return __v } @@ -2604,7 +2603,7 @@ func nvmlVgpuTypeGetMaxInstances(nvmlDevice nvmlDevice, nvmlVgpuTypeId nvmlVgpuT cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cVgpuInstanceCount, _ := (*C.uint)(unsafe.Pointer(VgpuInstanceCount)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetMaxInstances(cnvmlDevice, cnvmlVgpuTypeId, cVgpuInstanceCount) + __ret := C.dispatch_nvmlVgpuTypeGetMaxInstances(cnvmlDevice, cnvmlVgpuTypeId, cVgpuInstanceCount) __v := (Return)(__ret) return __v } @@ -2613,7 +2612,7 @@ func nvmlVgpuTypeGetMaxInstances(nvmlDevice nvmlDevice, nvmlVgpuTypeId nvmlVgpuT func nvmlVgpuTypeGetMaxInstancesPerVm(nvmlVgpuTypeId nvmlVgpuTypeId, VgpuInstanceCountPerVm *uint32) Return { cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cVgpuInstanceCountPerVm, _ := (*C.uint)(unsafe.Pointer(VgpuInstanceCountPerVm)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetMaxInstancesPerVm(cnvmlVgpuTypeId, cVgpuInstanceCountPerVm) + __ret := C.dispatch_nvmlVgpuTypeGetMaxInstancesPerVm(cnvmlVgpuTypeId, cVgpuInstanceCountPerVm) __v := (Return)(__ret) return __v } @@ -2622,7 +2621,7 @@ func nvmlVgpuTypeGetMaxInstancesPerVm(nvmlVgpuTypeId nvmlVgpuTypeId, VgpuInstanc func nvmlVgpuTypeGetBAR1Info(nvmlVgpuTypeId nvmlVgpuTypeId, Bar1Info *VgpuTypeBar1Info) Return { cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cBar1Info, _ := (*C.nvmlVgpuTypeBar1Info_t)(unsafe.Pointer(Bar1Info)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetBAR1Info(cnvmlVgpuTypeId, cBar1Info) + __ret := C.dispatch_nvmlVgpuTypeGetBAR1Info(cnvmlVgpuTypeId, cBar1Info) __v := (Return)(__ret) return __v } @@ -2632,7 +2631,7 @@ func nvmlDeviceGetActiveVgpus(nvmlDevice nvmlDevice, VgpuCount *uint32, VgpuInst cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cVgpuCount, _ := (*C.uint)(unsafe.Pointer(VgpuCount)), cgoAllocsUnknown cVgpuInstances, _ := (*C.nvmlVgpuInstance_t)(unsafe.Pointer(VgpuInstances)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetActiveVgpus(cnvmlDevice, cVgpuCount, cVgpuInstances) + __ret := C.dispatch_nvmlDeviceGetActiveVgpus(cnvmlDevice, cVgpuCount, cVgpuInstances) __v := (Return)(__ret) return __v } @@ -2643,7 +2642,7 @@ func nvmlVgpuInstanceGetVmID(nvmlVgpuInstance nvmlVgpuInstance, VmId *byte, Size cVmId, _ := (*C.char)(unsafe.Pointer(VmId)), cgoAllocsUnknown cSize, _ := (C.uint)(Size), cgoAllocsUnknown cVmIdType, _ := (*C.nvmlVgpuVmIdType_t)(unsafe.Pointer(VmIdType)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetVmID(cnvmlVgpuInstance, cVmId, cSize, cVmIdType) + __ret := C.dispatch_nvmlVgpuInstanceGetVmID(cnvmlVgpuInstance, cVmId, cSize, cVmIdType) __v := (Return)(__ret) return __v } @@ -2653,7 +2652,7 @@ func nvmlVgpuInstanceGetUUID(nvmlVgpuInstance nvmlVgpuInstance, Uuid *byte, Size cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cUuid, _ := (*C.char)(unsafe.Pointer(Uuid)), cgoAllocsUnknown cSize, _ := (C.uint)(Size), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetUUID(cnvmlVgpuInstance, cUuid, cSize) + __ret := C.dispatch_nvmlVgpuInstanceGetUUID(cnvmlVgpuInstance, cUuid, cSize) __v := (Return)(__ret) return __v } @@ -2663,7 +2662,7 @@ func nvmlVgpuInstanceGetVmDriverVersion(nvmlVgpuInstance nvmlVgpuInstance, Versi cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cVersion, _ := (*C.char)(unsafe.Pointer(Version)), cgoAllocsUnknown cLength, _ := (C.uint)(Length), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetVmDriverVersion(cnvmlVgpuInstance, cVersion, cLength) + __ret := C.dispatch_nvmlVgpuInstanceGetVmDriverVersion(cnvmlVgpuInstance, cVersion, cLength) __v := (Return)(__ret) return __v } @@ -2672,7 +2671,7 @@ func nvmlVgpuInstanceGetVmDriverVersion(nvmlVgpuInstance nvmlVgpuInstance, Versi func nvmlVgpuInstanceGetFbUsage(nvmlVgpuInstance nvmlVgpuInstance, FbUsage *uint64) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cFbUsage, _ := (*C.ulonglong)(unsafe.Pointer(FbUsage)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetFbUsage(cnvmlVgpuInstance, cFbUsage) + __ret := C.dispatch_nvmlVgpuInstanceGetFbUsage(cnvmlVgpuInstance, cFbUsage) __v := (Return)(__ret) return __v } @@ -2681,7 +2680,7 @@ func nvmlVgpuInstanceGetFbUsage(nvmlVgpuInstance nvmlVgpuInstance, FbUsage *uint func nvmlVgpuInstanceGetLicenseStatus(nvmlVgpuInstance nvmlVgpuInstance, Licensed *uint32) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cLicensed, _ := (*C.uint)(unsafe.Pointer(Licensed)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetLicenseStatus(cnvmlVgpuInstance, cLicensed) + __ret := C.dispatch_nvmlVgpuInstanceGetLicenseStatus(cnvmlVgpuInstance, cLicensed) __v := (Return)(__ret) return __v } @@ -2690,7 +2689,7 @@ func nvmlVgpuInstanceGetLicenseStatus(nvmlVgpuInstance nvmlVgpuInstance, License func nvmlVgpuInstanceGetType(nvmlVgpuInstance nvmlVgpuInstance, nvmlVgpuTypeId *nvmlVgpuTypeId) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cnvmlVgpuTypeId, _ := (*C.nvmlVgpuTypeId_t)(unsafe.Pointer(nvmlVgpuTypeId)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetType(cnvmlVgpuInstance, cnvmlVgpuTypeId) + __ret := C.dispatch_nvmlVgpuInstanceGetType(cnvmlVgpuInstance, cnvmlVgpuTypeId) __v := (Return)(__ret) return __v } @@ -2699,7 +2698,7 @@ func nvmlVgpuInstanceGetType(nvmlVgpuInstance nvmlVgpuInstance, nvmlVgpuTypeId * func nvmlVgpuInstanceGetFrameRateLimit(nvmlVgpuInstance nvmlVgpuInstance, FrameRateLimit *uint32) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cFrameRateLimit, _ := (*C.uint)(unsafe.Pointer(FrameRateLimit)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetFrameRateLimit(cnvmlVgpuInstance, cFrameRateLimit) + __ret := C.dispatch_nvmlVgpuInstanceGetFrameRateLimit(cnvmlVgpuInstance, cFrameRateLimit) __v := (Return)(__ret) return __v } @@ -2708,7 +2707,7 @@ func nvmlVgpuInstanceGetFrameRateLimit(nvmlVgpuInstance nvmlVgpuInstance, FrameR func nvmlVgpuInstanceGetEccMode(nvmlVgpuInstance nvmlVgpuInstance, EccMode *EnableState) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cEccMode, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(EccMode)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetEccMode(cnvmlVgpuInstance, cEccMode) + __ret := C.dispatch_nvmlVgpuInstanceGetEccMode(cnvmlVgpuInstance, cEccMode) __v := (Return)(__ret) return __v } @@ -2717,7 +2716,7 @@ func nvmlVgpuInstanceGetEccMode(nvmlVgpuInstance nvmlVgpuInstance, EccMode *Enab func nvmlVgpuInstanceGetEncoderCapacity(nvmlVgpuInstance nvmlVgpuInstance, EncoderCapacity *uint32) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cEncoderCapacity, _ := (*C.uint)(unsafe.Pointer(EncoderCapacity)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetEncoderCapacity(cnvmlVgpuInstance, cEncoderCapacity) + __ret := C.dispatch_nvmlVgpuInstanceGetEncoderCapacity(cnvmlVgpuInstance, cEncoderCapacity) __v := (Return)(__ret) return __v } @@ -2726,7 +2725,7 @@ func nvmlVgpuInstanceGetEncoderCapacity(nvmlVgpuInstance nvmlVgpuInstance, Encod func nvmlVgpuInstanceSetEncoderCapacity(nvmlVgpuInstance nvmlVgpuInstance, EncoderCapacity uint32) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cEncoderCapacity, _ := (C.uint)(EncoderCapacity), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceSetEncoderCapacity(cnvmlVgpuInstance, cEncoderCapacity) + __ret := C.dispatch_nvmlVgpuInstanceSetEncoderCapacity(cnvmlVgpuInstance, cEncoderCapacity) __v := (Return)(__ret) return __v } @@ -2737,7 +2736,7 @@ func nvmlVgpuInstanceGetEncoderStats(nvmlVgpuInstance nvmlVgpuInstance, SessionC cSessionCount, _ := (*C.uint)(unsafe.Pointer(SessionCount)), cgoAllocsUnknown cAverageFps, _ := (*C.uint)(unsafe.Pointer(AverageFps)), cgoAllocsUnknown cAverageLatency, _ := (*C.uint)(unsafe.Pointer(AverageLatency)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetEncoderStats(cnvmlVgpuInstance, cSessionCount, cAverageFps, cAverageLatency) + __ret := C.dispatch_nvmlVgpuInstanceGetEncoderStats(cnvmlVgpuInstance, cSessionCount, cAverageFps, cAverageLatency) __v := (Return)(__ret) return __v } @@ -2747,7 +2746,7 @@ func nvmlVgpuInstanceGetEncoderSessions(nvmlVgpuInstance nvmlVgpuInstance, Sessi cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cSessionCount, _ := (*C.uint)(unsafe.Pointer(SessionCount)), cgoAllocsUnknown cSessionInfo, _ := (*C.nvmlEncoderSessionInfo_t)(unsafe.Pointer(SessionInfo)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetEncoderSessions(cnvmlVgpuInstance, cSessionCount, cSessionInfo) + __ret := C.dispatch_nvmlVgpuInstanceGetEncoderSessions(cnvmlVgpuInstance, cSessionCount, cSessionInfo) __v := (Return)(__ret) return __v } @@ -2756,7 +2755,7 @@ func nvmlVgpuInstanceGetEncoderSessions(nvmlVgpuInstance nvmlVgpuInstance, Sessi func nvmlVgpuInstanceGetFBCStats(nvmlVgpuInstance nvmlVgpuInstance, FbcStats *FBCStats) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cFbcStats, _ := (*C.nvmlFBCStats_t)(unsafe.Pointer(FbcStats)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetFBCStats(cnvmlVgpuInstance, cFbcStats) + __ret := C.dispatch_nvmlVgpuInstanceGetFBCStats(cnvmlVgpuInstance, cFbcStats) __v := (Return)(__ret) return __v } @@ -2766,7 +2765,7 @@ func nvmlVgpuInstanceGetFBCSessions(nvmlVgpuInstance nvmlVgpuInstance, SessionCo cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cSessionCount, _ := (*C.uint)(unsafe.Pointer(SessionCount)), cgoAllocsUnknown cSessionInfo, _ := (*C.nvmlFBCSessionInfo_t)(unsafe.Pointer(SessionInfo)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetFBCSessions(cnvmlVgpuInstance, cSessionCount, cSessionInfo) + __ret := C.dispatch_nvmlVgpuInstanceGetFBCSessions(cnvmlVgpuInstance, cSessionCount, cSessionInfo) __v := (Return)(__ret) return __v } @@ -2775,7 +2774,7 @@ func nvmlVgpuInstanceGetFBCSessions(nvmlVgpuInstance nvmlVgpuInstance, SessionCo func nvmlVgpuInstanceGetGpuInstanceId(nvmlVgpuInstance nvmlVgpuInstance, GpuInstanceId *uint32) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cGpuInstanceId, _ := (*C.uint)(unsafe.Pointer(GpuInstanceId)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetGpuInstanceId(cnvmlVgpuInstance, cGpuInstanceId) + __ret := C.dispatch_nvmlVgpuInstanceGetGpuInstanceId(cnvmlVgpuInstance, cGpuInstanceId) __v := (Return)(__ret) return __v } @@ -2785,7 +2784,7 @@ func nvmlVgpuInstanceGetGpuPciId(nvmlVgpuInstance nvmlVgpuInstance, VgpuPciId *b cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cVgpuPciId, _ := (*C.char)(unsafe.Pointer(VgpuPciId)), cgoAllocsUnknown cLength, _ := (*C.uint)(unsafe.Pointer(Length)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetGpuPciId(cnvmlVgpuInstance, cVgpuPciId, cLength) + __ret := C.dispatch_nvmlVgpuInstanceGetGpuPciId(cnvmlVgpuInstance, cVgpuPciId, cLength) __v := (Return)(__ret) return __v } @@ -2795,7 +2794,7 @@ func nvmlVgpuTypeGetCapabilities(nvmlVgpuTypeId nvmlVgpuTypeId, Capability VgpuC cnvmlVgpuTypeId, _ := (C.nvmlVgpuTypeId_t)(nvmlVgpuTypeId), cgoAllocsUnknown cCapability, _ := (C.nvmlVgpuCapability_t)(Capability), cgoAllocsUnknown cCapResult, _ := (*C.uint)(unsafe.Pointer(CapResult)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetCapabilities(cnvmlVgpuTypeId, cCapability, cCapResult) + __ret := C.dispatch_nvmlVgpuTypeGetCapabilities(cnvmlVgpuTypeId, cCapability, cCapResult) __v := (Return)(__ret) return __v } @@ -2805,7 +2804,7 @@ func nvmlVgpuInstanceGetMdevUUID(nvmlVgpuInstance nvmlVgpuInstance, MdevUuid *by cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cMdevUuid, _ := (*C.char)(unsafe.Pointer(MdevUuid)), cgoAllocsUnknown cSize, _ := (C.uint)(Size), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetMdevUUID(cnvmlVgpuInstance, cMdevUuid, cSize) + __ret := C.dispatch_nvmlVgpuInstanceGetMdevUUID(cnvmlVgpuInstance, cMdevUuid, cSize) __v := (Return)(__ret) return __v } @@ -2814,7 +2813,7 @@ func nvmlVgpuInstanceGetMdevUUID(nvmlVgpuInstance nvmlVgpuInstance, MdevUuid *by func nvmlGpuInstanceGetCreatableVgpus(nvmlGpuInstance nvmlGpuInstance, PVgpus *VgpuTypeIdInfo) Return { cnvmlGpuInstance, _ := *(*C.nvmlGpuInstance_t)(unsafe.Pointer(&nvmlGpuInstance)), cgoAllocsUnknown cPVgpus, _ := (*C.nvmlVgpuTypeIdInfo_t)(unsafe.Pointer(PVgpus)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceGetCreatableVgpus(cnvmlGpuInstance, cPVgpus) + __ret := C.dispatch_nvmlGpuInstanceGetCreatableVgpus(cnvmlGpuInstance, cPVgpus) __v := (Return)(__ret) return __v } @@ -2822,7 +2821,7 @@ func nvmlGpuInstanceGetCreatableVgpus(nvmlGpuInstance nvmlGpuInstance, PVgpus *V // nvmlVgpuTypeGetMaxInstancesPerGpuInstance function as declared in nvml/nvml.h func nvmlVgpuTypeGetMaxInstancesPerGpuInstance(PMaxInstance *VgpuTypeMaxInstance) Return { cPMaxInstance, _ := (*C.nvmlVgpuTypeMaxInstance_t)(unsafe.Pointer(PMaxInstance)), cgoAllocsUnknown - __ret := C.nvmlVgpuTypeGetMaxInstancesPerGpuInstance(cPMaxInstance) + __ret := C.dispatch_nvmlVgpuTypeGetMaxInstancesPerGpuInstance(cPMaxInstance) __v := (Return)(__ret) return __v } @@ -2831,7 +2830,7 @@ func nvmlVgpuTypeGetMaxInstancesPerGpuInstance(PMaxInstance *VgpuTypeMaxInstance func nvmlGpuInstanceGetActiveVgpus(nvmlGpuInstance nvmlGpuInstance, PVgpuInstanceInfo *ActiveVgpuInstanceInfo) Return { cnvmlGpuInstance, _ := *(*C.nvmlGpuInstance_t)(unsafe.Pointer(&nvmlGpuInstance)), cgoAllocsUnknown cPVgpuInstanceInfo, _ := (*C.nvmlActiveVgpuInstanceInfo_t)(unsafe.Pointer(PVgpuInstanceInfo)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceGetActiveVgpus(cnvmlGpuInstance, cPVgpuInstanceInfo) + __ret := C.dispatch_nvmlGpuInstanceGetActiveVgpus(cnvmlGpuInstance, cPVgpuInstanceInfo) __v := (Return)(__ret) return __v } @@ -2840,7 +2839,7 @@ func nvmlGpuInstanceGetActiveVgpus(nvmlGpuInstance nvmlGpuInstance, PVgpuInstanc func nvmlGpuInstanceSetVgpuSchedulerState(nvmlGpuInstance nvmlGpuInstance, PScheduler *VgpuSchedulerState) Return { cnvmlGpuInstance, _ := *(*C.nvmlGpuInstance_t)(unsafe.Pointer(&nvmlGpuInstance)), cgoAllocsUnknown cPScheduler, _ := (*C.nvmlVgpuSchedulerState_t)(unsafe.Pointer(PScheduler)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceSetVgpuSchedulerState(cnvmlGpuInstance, cPScheduler) + __ret := C.dispatch_nvmlGpuInstanceSetVgpuSchedulerState(cnvmlGpuInstance, cPScheduler) __v := (Return)(__ret) return __v } @@ -2849,7 +2848,7 @@ func nvmlGpuInstanceSetVgpuSchedulerState(nvmlGpuInstance nvmlGpuInstance, PSche func nvmlGpuInstanceGetVgpuSchedulerState(nvmlGpuInstance nvmlGpuInstance, PSchedulerStateInfo *VgpuSchedulerStateInfo) Return { cnvmlGpuInstance, _ := *(*C.nvmlGpuInstance_t)(unsafe.Pointer(&nvmlGpuInstance)), cgoAllocsUnknown cPSchedulerStateInfo, _ := (*C.nvmlVgpuSchedulerStateInfo_t)(unsafe.Pointer(PSchedulerStateInfo)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceGetVgpuSchedulerState(cnvmlGpuInstance, cPSchedulerStateInfo) + __ret := C.dispatch_nvmlGpuInstanceGetVgpuSchedulerState(cnvmlGpuInstance, cPSchedulerStateInfo) __v := (Return)(__ret) return __v } @@ -2858,7 +2857,7 @@ func nvmlGpuInstanceGetVgpuSchedulerState(nvmlGpuInstance nvmlGpuInstance, PSche func nvmlGpuInstanceGetVgpuSchedulerLog(nvmlGpuInstance nvmlGpuInstance, PSchedulerLogInfo *VgpuSchedulerLogInfo) Return { cnvmlGpuInstance, _ := *(*C.nvmlGpuInstance_t)(unsafe.Pointer(&nvmlGpuInstance)), cgoAllocsUnknown cPSchedulerLogInfo, _ := (*C.nvmlVgpuSchedulerLogInfo_t)(unsafe.Pointer(PSchedulerLogInfo)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceGetVgpuSchedulerLog(cnvmlGpuInstance, cPSchedulerLogInfo) + __ret := C.dispatch_nvmlGpuInstanceGetVgpuSchedulerLog(cnvmlGpuInstance, cPSchedulerLogInfo) __v := (Return)(__ret) return __v } @@ -2867,7 +2866,7 @@ func nvmlGpuInstanceGetVgpuSchedulerLog(nvmlGpuInstance nvmlGpuInstance, PSchedu func nvmlGpuInstanceGetVgpuTypeCreatablePlacements(nvmlGpuInstance nvmlGpuInstance, PCreatablePlacementInfo *VgpuCreatablePlacementInfo) Return { cnvmlGpuInstance, _ := *(*C.nvmlGpuInstance_t)(unsafe.Pointer(&nvmlGpuInstance)), cgoAllocsUnknown cPCreatablePlacementInfo, _ := (*C.nvmlVgpuCreatablePlacementInfo_t)(unsafe.Pointer(PCreatablePlacementInfo)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceGetVgpuTypeCreatablePlacements(cnvmlGpuInstance, cPCreatablePlacementInfo) + __ret := C.dispatch_nvmlGpuInstanceGetVgpuTypeCreatablePlacements(cnvmlGpuInstance, cPCreatablePlacementInfo) __v := (Return)(__ret) return __v } @@ -2876,7 +2875,7 @@ func nvmlGpuInstanceGetVgpuTypeCreatablePlacements(nvmlGpuInstance nvmlGpuInstan func nvmlGpuInstanceGetVgpuHeterogeneousMode(nvmlGpuInstance nvmlGpuInstance, PHeterogeneousMode *VgpuHeterogeneousMode) Return { cnvmlGpuInstance, _ := *(*C.nvmlGpuInstance_t)(unsafe.Pointer(&nvmlGpuInstance)), cgoAllocsUnknown cPHeterogeneousMode, _ := (*C.nvmlVgpuHeterogeneousMode_t)(unsafe.Pointer(PHeterogeneousMode)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceGetVgpuHeterogeneousMode(cnvmlGpuInstance, cPHeterogeneousMode) + __ret := C.dispatch_nvmlGpuInstanceGetVgpuHeterogeneousMode(cnvmlGpuInstance, cPHeterogeneousMode) __v := (Return)(__ret) return __v } @@ -2885,7 +2884,7 @@ func nvmlGpuInstanceGetVgpuHeterogeneousMode(nvmlGpuInstance nvmlGpuInstance, PH func nvmlGpuInstanceSetVgpuHeterogeneousMode(nvmlGpuInstance nvmlGpuInstance, PHeterogeneousMode *VgpuHeterogeneousMode) Return { cnvmlGpuInstance, _ := *(*C.nvmlGpuInstance_t)(unsafe.Pointer(&nvmlGpuInstance)), cgoAllocsUnknown cPHeterogeneousMode, _ := (*C.nvmlVgpuHeterogeneousMode_t)(unsafe.Pointer(PHeterogeneousMode)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceSetVgpuHeterogeneousMode(cnvmlGpuInstance, cPHeterogeneousMode) + __ret := C.dispatch_nvmlGpuInstanceSetVgpuHeterogeneousMode(cnvmlGpuInstance, cPHeterogeneousMode) __v := (Return)(__ret) return __v } @@ -2895,7 +2894,7 @@ func nvmlVgpuInstanceGetMetadata(nvmlVgpuInstance nvmlVgpuInstance, nvmlVgpuMeta cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cnvmlVgpuMetadata, _ := (*C.nvmlVgpuMetadata_t)(unsafe.Pointer(nvmlVgpuMetadata)), cgoAllocsUnknown cBufferSize, _ := (*C.uint)(unsafe.Pointer(BufferSize)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetMetadata(cnvmlVgpuInstance, cnvmlVgpuMetadata, cBufferSize) + __ret := C.dispatch_nvmlVgpuInstanceGetMetadata(cnvmlVgpuInstance, cnvmlVgpuMetadata, cBufferSize) __v := (Return)(__ret) return __v } @@ -2905,7 +2904,7 @@ func nvmlDeviceGetVgpuMetadata(nvmlDevice nvmlDevice, PgpuMetadata *nvmlVgpuPgpu cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPgpuMetadata, _ := (*C.nvmlVgpuPgpuMetadata_t)(unsafe.Pointer(PgpuMetadata)), cgoAllocsUnknown cBufferSize, _ := (*C.uint)(unsafe.Pointer(BufferSize)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetVgpuMetadata(cnvmlDevice, cPgpuMetadata, cBufferSize) + __ret := C.dispatch_nvmlDeviceGetVgpuMetadata(cnvmlDevice, cPgpuMetadata, cBufferSize) __v := (Return)(__ret) return __v } @@ -2915,7 +2914,7 @@ func nvmlGetVgpuCompatibility(nvmlVgpuMetadata *nvmlVgpuMetadata, PgpuMetadata * cnvmlVgpuMetadata, _ := (*C.nvmlVgpuMetadata_t)(unsafe.Pointer(nvmlVgpuMetadata)), cgoAllocsUnknown cPgpuMetadata, _ := (*C.nvmlVgpuPgpuMetadata_t)(unsafe.Pointer(PgpuMetadata)), cgoAllocsUnknown cCompatibilityInfo, _ := (*C.nvmlVgpuPgpuCompatibility_t)(unsafe.Pointer(CompatibilityInfo)), cgoAllocsUnknown - __ret := C.nvmlGetVgpuCompatibility(cnvmlVgpuMetadata, cPgpuMetadata, cCompatibilityInfo) + __ret := C.dispatch_nvmlGetVgpuCompatibility(cnvmlVgpuMetadata, cPgpuMetadata, cCompatibilityInfo) __v := (Return)(__ret) return __v } @@ -2925,7 +2924,7 @@ func nvmlDeviceGetPgpuMetadataString(nvmlDevice nvmlDevice, PgpuMetadata *byte, cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPgpuMetadata, _ := (*C.char)(unsafe.Pointer(PgpuMetadata)), cgoAllocsUnknown cBufferSize, _ := (*C.uint)(unsafe.Pointer(BufferSize)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPgpuMetadataString(cnvmlDevice, cPgpuMetadata, cBufferSize) + __ret := C.dispatch_nvmlDeviceGetPgpuMetadataString(cnvmlDevice, cPgpuMetadata, cBufferSize) __v := (Return)(__ret) return __v } @@ -2934,7 +2933,7 @@ func nvmlDeviceGetPgpuMetadataString(nvmlDevice nvmlDevice, PgpuMetadata *byte, func nvmlDeviceGetVgpuSchedulerLog(nvmlDevice nvmlDevice, PSchedulerLog *VgpuSchedulerLog) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPSchedulerLog, _ := (*C.nvmlVgpuSchedulerLog_t)(unsafe.Pointer(PSchedulerLog)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetVgpuSchedulerLog(cnvmlDevice, cPSchedulerLog) + __ret := C.dispatch_nvmlDeviceGetVgpuSchedulerLog(cnvmlDevice, cPSchedulerLog) __v := (Return)(__ret) return __v } @@ -2943,7 +2942,7 @@ func nvmlDeviceGetVgpuSchedulerLog(nvmlDevice nvmlDevice, PSchedulerLog *VgpuSch func nvmlDeviceGetVgpuSchedulerState(nvmlDevice nvmlDevice, PSchedulerState *VgpuSchedulerGetState) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPSchedulerState, _ := (*C.nvmlVgpuSchedulerGetState_t)(unsafe.Pointer(PSchedulerState)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetVgpuSchedulerState(cnvmlDevice, cPSchedulerState) + __ret := C.dispatch_nvmlDeviceGetVgpuSchedulerState(cnvmlDevice, cPSchedulerState) __v := (Return)(__ret) return __v } @@ -2952,7 +2951,7 @@ func nvmlDeviceGetVgpuSchedulerState(nvmlDevice nvmlDevice, PSchedulerState *Vgp func nvmlDeviceGetVgpuSchedulerCapabilities(nvmlDevice nvmlDevice, PCapabilities *VgpuSchedulerCapabilities) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPCapabilities, _ := (*C.nvmlVgpuSchedulerCapabilities_t)(unsafe.Pointer(PCapabilities)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetVgpuSchedulerCapabilities(cnvmlDevice, cPCapabilities) + __ret := C.dispatch_nvmlDeviceGetVgpuSchedulerCapabilities(cnvmlDevice, cPCapabilities) __v := (Return)(__ret) return __v } @@ -2961,7 +2960,7 @@ func nvmlDeviceGetVgpuSchedulerCapabilities(nvmlDevice nvmlDevice, PCapabilities func nvmlDeviceSetVgpuSchedulerState(nvmlDevice nvmlDevice, PSchedulerState *VgpuSchedulerSetState) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPSchedulerState, _ := (*C.nvmlVgpuSchedulerSetState_t)(unsafe.Pointer(PSchedulerState)), cgoAllocsUnknown - __ret := C.nvmlDeviceSetVgpuSchedulerState(cnvmlDevice, cPSchedulerState) + __ret := C.dispatch_nvmlDeviceSetVgpuSchedulerState(cnvmlDevice, cPSchedulerState) __v := (Return)(__ret) return __v } @@ -2970,7 +2969,7 @@ func nvmlDeviceSetVgpuSchedulerState(nvmlDevice nvmlDevice, PSchedulerState *Vgp func nvmlGetVgpuVersion(Supported *VgpuVersion, Current *VgpuVersion) Return { cSupported, _ := (*C.nvmlVgpuVersion_t)(unsafe.Pointer(Supported)), cgoAllocsUnknown cCurrent, _ := (*C.nvmlVgpuVersion_t)(unsafe.Pointer(Current)), cgoAllocsUnknown - __ret := C.nvmlGetVgpuVersion(cSupported, cCurrent) + __ret := C.dispatch_nvmlGetVgpuVersion(cSupported, cCurrent) __v := (Return)(__ret) return __v } @@ -2978,7 +2977,7 @@ func nvmlGetVgpuVersion(Supported *VgpuVersion, Current *VgpuVersion) Return { // nvmlSetVgpuVersion function as declared in nvml/nvml.h func nvmlSetVgpuVersion(VgpuVersion *VgpuVersion) Return { cVgpuVersion, _ := (*C.nvmlVgpuVersion_t)(unsafe.Pointer(VgpuVersion)), cgoAllocsUnknown - __ret := C.nvmlSetVgpuVersion(cVgpuVersion) + __ret := C.dispatch_nvmlSetVgpuVersion(cVgpuVersion) __v := (Return)(__ret) return __v } @@ -2990,7 +2989,7 @@ func nvmlDeviceGetVgpuUtilization(nvmlDevice nvmlDevice, LastSeenTimeStamp uint6 cSampleValType, _ := (*C.nvmlValueType_t)(unsafe.Pointer(SampleValType)), cgoAllocsUnknown cVgpuInstanceSamplesCount, _ := (*C.uint)(unsafe.Pointer(VgpuInstanceSamplesCount)), cgoAllocsUnknown cUtilizationSamples, _ := (*C.nvmlVgpuInstanceUtilizationSample_t)(unsafe.Pointer(UtilizationSamples)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetVgpuUtilization(cnvmlDevice, cLastSeenTimeStamp, cSampleValType, cVgpuInstanceSamplesCount, cUtilizationSamples) + __ret := C.dispatch_nvmlDeviceGetVgpuUtilization(cnvmlDevice, cLastSeenTimeStamp, cSampleValType, cVgpuInstanceSamplesCount, cUtilizationSamples) __v := (Return)(__ret) return __v } @@ -2999,7 +2998,7 @@ func nvmlDeviceGetVgpuUtilization(nvmlDevice nvmlDevice, LastSeenTimeStamp uint6 func nvmlDeviceGetVgpuInstancesUtilizationInfo(nvmlDevice nvmlDevice, VgpuUtilInfo *VgpuInstancesUtilizationInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cVgpuUtilInfo, _ := (*C.nvmlVgpuInstancesUtilizationInfo_t)(unsafe.Pointer(VgpuUtilInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetVgpuInstancesUtilizationInfo(cnvmlDevice, cVgpuUtilInfo) + __ret := C.dispatch_nvmlDeviceGetVgpuInstancesUtilizationInfo(cnvmlDevice, cVgpuUtilInfo) __v := (Return)(__ret) return __v } @@ -3010,7 +3009,7 @@ func nvmlDeviceGetVgpuProcessUtilization(nvmlDevice nvmlDevice, LastSeenTimeStam cLastSeenTimeStamp, _ := (C.ulonglong)(LastSeenTimeStamp), cgoAllocsUnknown cVgpuProcessSamplesCount, _ := (*C.uint)(unsafe.Pointer(VgpuProcessSamplesCount)), cgoAllocsUnknown cUtilizationSamples, _ := (*C.nvmlVgpuProcessUtilizationSample_t)(unsafe.Pointer(UtilizationSamples)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetVgpuProcessUtilization(cnvmlDevice, cLastSeenTimeStamp, cVgpuProcessSamplesCount, cUtilizationSamples) + __ret := C.dispatch_nvmlDeviceGetVgpuProcessUtilization(cnvmlDevice, cLastSeenTimeStamp, cVgpuProcessSamplesCount, cUtilizationSamples) __v := (Return)(__ret) return __v } @@ -3019,7 +3018,7 @@ func nvmlDeviceGetVgpuProcessUtilization(nvmlDevice nvmlDevice, LastSeenTimeStam func nvmlDeviceGetVgpuProcessesUtilizationInfo(nvmlDevice nvmlDevice, VgpuProcUtilInfo *VgpuProcessesUtilizationInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cVgpuProcUtilInfo, _ := (*C.nvmlVgpuProcessesUtilizationInfo_t)(unsafe.Pointer(VgpuProcUtilInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetVgpuProcessesUtilizationInfo(cnvmlDevice, cVgpuProcUtilInfo) + __ret := C.dispatch_nvmlDeviceGetVgpuProcessesUtilizationInfo(cnvmlDevice, cVgpuProcUtilInfo) __v := (Return)(__ret) return __v } @@ -3028,7 +3027,7 @@ func nvmlDeviceGetVgpuProcessesUtilizationInfo(nvmlDevice nvmlDevice, VgpuProcUt func nvmlVgpuInstanceGetAccountingMode(nvmlVgpuInstance nvmlVgpuInstance, Mode *EnableState) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cMode, _ := (*C.nvmlEnableState_t)(unsafe.Pointer(Mode)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetAccountingMode(cnvmlVgpuInstance, cMode) + __ret := C.dispatch_nvmlVgpuInstanceGetAccountingMode(cnvmlVgpuInstance, cMode) __v := (Return)(__ret) return __v } @@ -3038,7 +3037,7 @@ func nvmlVgpuInstanceGetAccountingPids(nvmlVgpuInstance nvmlVgpuInstance, Count cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cCount, _ := (*C.uint)(unsafe.Pointer(Count)), cgoAllocsUnknown cPids, _ := (*C.uint)(unsafe.Pointer(Pids)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetAccountingPids(cnvmlVgpuInstance, cCount, cPids) + __ret := C.dispatch_nvmlVgpuInstanceGetAccountingPids(cnvmlVgpuInstance, cCount, cPids) __v := (Return)(__ret) return __v } @@ -3048,7 +3047,7 @@ func nvmlVgpuInstanceGetAccountingStats(nvmlVgpuInstance nvmlVgpuInstance, Pid u cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cPid, _ := (C.uint)(Pid), cgoAllocsUnknown cStats, _ := (*C.nvmlAccountingStats_t)(unsafe.Pointer(Stats)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetAccountingStats(cnvmlVgpuInstance, cPid, cStats) + __ret := C.dispatch_nvmlVgpuInstanceGetAccountingStats(cnvmlVgpuInstance, cPid, cStats) __v := (Return)(__ret) return __v } @@ -3056,7 +3055,7 @@ func nvmlVgpuInstanceGetAccountingStats(nvmlVgpuInstance nvmlVgpuInstance, Pid u // nvmlVgpuInstanceClearAccountingPids function as declared in nvml/nvml.h func nvmlVgpuInstanceClearAccountingPids(nvmlVgpuInstance nvmlVgpuInstance) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceClearAccountingPids(cnvmlVgpuInstance) + __ret := C.dispatch_nvmlVgpuInstanceClearAccountingPids(cnvmlVgpuInstance) __v := (Return)(__ret) return __v } @@ -3065,7 +3064,7 @@ func nvmlVgpuInstanceClearAccountingPids(nvmlVgpuInstance nvmlVgpuInstance) Retu func nvmlVgpuInstanceGetLicenseInfo_v2(nvmlVgpuInstance nvmlVgpuInstance, LicenseInfo *VgpuLicenseInfo) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cLicenseInfo, _ := (*C.nvmlVgpuLicenseInfo_t)(unsafe.Pointer(LicenseInfo)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetLicenseInfo_v2(cnvmlVgpuInstance, cLicenseInfo) + __ret := C.dispatch_nvmlVgpuInstanceGetLicenseInfo_v2(cnvmlVgpuInstance, cLicenseInfo) __v := (Return)(__ret) return __v } @@ -3073,7 +3072,7 @@ func nvmlVgpuInstanceGetLicenseInfo_v2(nvmlVgpuInstance nvmlVgpuInstance, Licens // nvmlGetExcludedDeviceCount function as declared in nvml/nvml.h func nvmlGetExcludedDeviceCount(DeviceCount *uint32) Return { cDeviceCount, _ := (*C.uint)(unsafe.Pointer(DeviceCount)), cgoAllocsUnknown - __ret := C.nvmlGetExcludedDeviceCount(cDeviceCount) + __ret := C.dispatch_nvmlGetExcludedDeviceCount(cDeviceCount) __v := (Return)(__ret) return __v } @@ -3082,7 +3081,7 @@ func nvmlGetExcludedDeviceCount(DeviceCount *uint32) Return { func nvmlGetExcludedDeviceInfoByIndex(Index uint32, Info *ExcludedDeviceInfo) Return { cIndex, _ := (C.uint)(Index), cgoAllocsUnknown cInfo, _ := (*C.nvmlExcludedDeviceInfo_t)(unsafe.Pointer(Info)), cgoAllocsUnknown - __ret := C.nvmlGetExcludedDeviceInfoByIndex(cIndex, cInfo) + __ret := C.dispatch_nvmlGetExcludedDeviceInfoByIndex(cIndex, cInfo) __v := (Return)(__ret) return __v } @@ -3091,7 +3090,7 @@ func nvmlGetExcludedDeviceInfoByIndex(Index uint32, Info *ExcludedDeviceInfo) Re func nvmlDeviceReadWritePRM_v1(nvmlDevice nvmlDevice, Buffer *PRMTLV_v1) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cBuffer, _ := (*C.nvmlPRMTLV_v1_t)(unsafe.Pointer(Buffer)), cgoAllocsUnknown - __ret := C.nvmlDeviceReadWritePRM_v1(cnvmlDevice, cBuffer) + __ret := C.dispatch_nvmlDeviceReadWritePRM_v1(cnvmlDevice, cBuffer) __v := (Return)(__ret) return __v } @@ -3101,7 +3100,7 @@ func nvmlDeviceSetMigMode(nvmlDevice nvmlDevice, Mode uint32, ActivationStatus * cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cMode, _ := (C.uint)(Mode), cgoAllocsUnknown cActivationStatus, _ := (*C.nvmlReturn_t)(unsafe.Pointer(ActivationStatus)), cgoAllocsUnknown - __ret := C.nvmlDeviceSetMigMode(cnvmlDevice, cMode, cActivationStatus) + __ret := C.dispatch_nvmlDeviceSetMigMode(cnvmlDevice, cMode, cActivationStatus) __v := (Return)(__ret) return __v } @@ -3111,7 +3110,7 @@ func nvmlDeviceGetMigMode(nvmlDevice nvmlDevice, CurrentMode *uint32, PendingMod cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCurrentMode, _ := (*C.uint)(unsafe.Pointer(CurrentMode)), cgoAllocsUnknown cPendingMode, _ := (*C.uint)(unsafe.Pointer(PendingMode)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMigMode(cnvmlDevice, cCurrentMode, cPendingMode) + __ret := C.dispatch_nvmlDeviceGetMigMode(cnvmlDevice, cCurrentMode, cPendingMode) __v := (Return)(__ret) return __v } @@ -3121,7 +3120,7 @@ func nvmlDeviceGetGpuInstanceProfileInfo(nvmlDevice nvmlDevice, Profile uint32, cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cProfile, _ := (C.uint)(Profile), cgoAllocsUnknown cInfo, _ := (*C.nvmlGpuInstanceProfileInfo_t)(unsafe.Pointer(Info)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpuInstanceProfileInfo(cnvmlDevice, cProfile, cInfo) + __ret := C.dispatch_nvmlDeviceGetGpuInstanceProfileInfo(cnvmlDevice, cProfile, cInfo) __v := (Return)(__ret) return __v } @@ -3131,7 +3130,7 @@ func nvmlDeviceGetGpuInstanceProfileInfoV(nvmlDevice nvmlDevice, Profile uint32, cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cProfile, _ := (C.uint)(Profile), cgoAllocsUnknown cInfo, _ := (*C.nvmlGpuInstanceProfileInfo_v2_t)(unsafe.Pointer(Info)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpuInstanceProfileInfoV(cnvmlDevice, cProfile, cInfo) + __ret := C.dispatch_nvmlDeviceGetGpuInstanceProfileInfoV(cnvmlDevice, cProfile, cInfo) __v := (Return)(__ret) return __v } @@ -3141,7 +3140,7 @@ func nvmlDeviceGetGpuInstanceProfileInfoByIdV(nvmlDevice nvmlDevice, ProfileId u cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cProfileId, _ := (C.uint)(ProfileId), cgoAllocsUnknown cInfo, _ := (*C.nvmlGpuInstanceProfileInfo_v2_t)(unsafe.Pointer(Info)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpuInstanceProfileInfoByIdV(cnvmlDevice, cProfileId, cInfo) + __ret := C.dispatch_nvmlDeviceGetGpuInstanceProfileInfoByIdV(cnvmlDevice, cProfileId, cInfo) __v := (Return)(__ret) return __v } @@ -3152,7 +3151,7 @@ func nvmlDeviceGetGpuInstancePossiblePlacements_v2(nvmlDevice nvmlDevice, Profil cProfileId, _ := (C.uint)(ProfileId), cgoAllocsUnknown cPlacements, _ := (*C.nvmlGpuInstancePlacement_t)(unsafe.Pointer(Placements)), cgoAllocsUnknown cCount, _ := (*C.uint)(unsafe.Pointer(Count)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpuInstancePossiblePlacements_v2(cnvmlDevice, cProfileId, cPlacements, cCount) + __ret := C.dispatch_nvmlDeviceGetGpuInstancePossiblePlacements_v2(cnvmlDevice, cProfileId, cPlacements, cCount) __v := (Return)(__ret) return __v } @@ -3162,7 +3161,7 @@ func nvmlDeviceGetGpuInstanceRemainingCapacity(nvmlDevice nvmlDevice, ProfileId cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cProfileId, _ := (C.uint)(ProfileId), cgoAllocsUnknown cCount, _ := (*C.uint)(unsafe.Pointer(Count)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpuInstanceRemainingCapacity(cnvmlDevice, cProfileId, cCount) + __ret := C.dispatch_nvmlDeviceGetGpuInstanceRemainingCapacity(cnvmlDevice, cProfileId, cCount) __v := (Return)(__ret) return __v } @@ -3172,7 +3171,7 @@ func nvmlDeviceCreateGpuInstance(nvmlDevice nvmlDevice, ProfileId uint32, nvmlGp cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cProfileId, _ := (C.uint)(ProfileId), cgoAllocsUnknown cnvmlGpuInstance, _ := (*C.nvmlGpuInstance_t)(unsafe.Pointer(nvmlGpuInstance)), cgoAllocsUnknown - __ret := C.nvmlDeviceCreateGpuInstance(cnvmlDevice, cProfileId, cnvmlGpuInstance) + __ret := C.dispatch_nvmlDeviceCreateGpuInstance(cnvmlDevice, cProfileId, cnvmlGpuInstance) __v := (Return)(__ret) return __v } @@ -3183,7 +3182,7 @@ func nvmlDeviceCreateGpuInstanceWithPlacement(nvmlDevice nvmlDevice, ProfileId u cProfileId, _ := (C.uint)(ProfileId), cgoAllocsUnknown cPlacement, _ := (*C.nvmlGpuInstancePlacement_t)(unsafe.Pointer(Placement)), cgoAllocsUnknown cnvmlGpuInstance, _ := (*C.nvmlGpuInstance_t)(unsafe.Pointer(nvmlGpuInstance)), cgoAllocsUnknown - __ret := C.nvmlDeviceCreateGpuInstanceWithPlacement(cnvmlDevice, cProfileId, cPlacement, cnvmlGpuInstance) + __ret := C.dispatch_nvmlDeviceCreateGpuInstanceWithPlacement(cnvmlDevice, cProfileId, cPlacement, cnvmlGpuInstance) __v := (Return)(__ret) return __v } @@ -3191,7 +3190,7 @@ func nvmlDeviceCreateGpuInstanceWithPlacement(nvmlDevice nvmlDevice, ProfileId u // nvmlGpuInstanceDestroy function as declared in nvml/nvml.h func nvmlGpuInstanceDestroy(nvmlGpuInstance nvmlGpuInstance) Return { cnvmlGpuInstance, _ := *(*C.nvmlGpuInstance_t)(unsafe.Pointer(&nvmlGpuInstance)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceDestroy(cnvmlGpuInstance) + __ret := C.dispatch_nvmlGpuInstanceDestroy(cnvmlGpuInstance) __v := (Return)(__ret) return __v } @@ -3202,7 +3201,7 @@ func nvmlDeviceGetGpuInstances(nvmlDevice nvmlDevice, ProfileId uint32, GpuInsta cProfileId, _ := (C.uint)(ProfileId), cgoAllocsUnknown cGpuInstances, _ := (*C.nvmlGpuInstance_t)(unsafe.Pointer(GpuInstances)), cgoAllocsUnknown cCount, _ := (*C.uint)(unsafe.Pointer(Count)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpuInstances(cnvmlDevice, cProfileId, cGpuInstances, cCount) + __ret := C.dispatch_nvmlDeviceGetGpuInstances(cnvmlDevice, cProfileId, cGpuInstances, cCount) __v := (Return)(__ret) return __v } @@ -3212,7 +3211,7 @@ func nvmlDeviceGetGpuInstanceById(nvmlDevice nvmlDevice, Id uint32, nvmlGpuInsta cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cId, _ := (C.uint)(Id), cgoAllocsUnknown cnvmlGpuInstance, _ := (*C.nvmlGpuInstance_t)(unsafe.Pointer(nvmlGpuInstance)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpuInstanceById(cnvmlDevice, cId, cnvmlGpuInstance) + __ret := C.dispatch_nvmlDeviceGetGpuInstanceById(cnvmlDevice, cId, cnvmlGpuInstance) __v := (Return)(__ret) return __v } @@ -3221,7 +3220,7 @@ func nvmlDeviceGetGpuInstanceById(nvmlDevice nvmlDevice, Id uint32, nvmlGpuInsta func nvmlGpuInstanceGetInfo(nvmlGpuInstance nvmlGpuInstance, Info *nvmlGpuInstanceInfo) Return { cnvmlGpuInstance, _ := *(*C.nvmlGpuInstance_t)(unsafe.Pointer(&nvmlGpuInstance)), cgoAllocsUnknown cInfo, _ := (*C.nvmlGpuInstanceInfo_t)(unsafe.Pointer(Info)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceGetInfo(cnvmlGpuInstance, cInfo) + __ret := C.dispatch_nvmlGpuInstanceGetInfo(cnvmlGpuInstance, cInfo) __v := (Return)(__ret) return __v } @@ -3232,7 +3231,7 @@ func nvmlGpuInstanceGetComputeInstanceProfileInfo(nvmlGpuInstance nvmlGpuInstanc cProfile, _ := (C.uint)(Profile), cgoAllocsUnknown cEngProfile, _ := (C.uint)(EngProfile), cgoAllocsUnknown cInfo, _ := (*C.nvmlComputeInstanceProfileInfo_t)(unsafe.Pointer(Info)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceGetComputeInstanceProfileInfo(cnvmlGpuInstance, cProfile, cEngProfile, cInfo) + __ret := C.dispatch_nvmlGpuInstanceGetComputeInstanceProfileInfo(cnvmlGpuInstance, cProfile, cEngProfile, cInfo) __v := (Return)(__ret) return __v } @@ -3243,7 +3242,7 @@ func nvmlGpuInstanceGetComputeInstanceProfileInfoV(nvmlGpuInstance nvmlGpuInstan cProfile, _ := (C.uint)(Profile), cgoAllocsUnknown cEngProfile, _ := (C.uint)(EngProfile), cgoAllocsUnknown cInfo, _ := (*C.nvmlComputeInstanceProfileInfo_v2_t)(unsafe.Pointer(Info)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceGetComputeInstanceProfileInfoV(cnvmlGpuInstance, cProfile, cEngProfile, cInfo) + __ret := C.dispatch_nvmlGpuInstanceGetComputeInstanceProfileInfoV(cnvmlGpuInstance, cProfile, cEngProfile, cInfo) __v := (Return)(__ret) return __v } @@ -3253,7 +3252,7 @@ func nvmlGpuInstanceGetComputeInstanceRemainingCapacity(nvmlGpuInstance nvmlGpuI cnvmlGpuInstance, _ := *(*C.nvmlGpuInstance_t)(unsafe.Pointer(&nvmlGpuInstance)), cgoAllocsUnknown cProfileId, _ := (C.uint)(ProfileId), cgoAllocsUnknown cCount, _ := (*C.uint)(unsafe.Pointer(Count)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceGetComputeInstanceRemainingCapacity(cnvmlGpuInstance, cProfileId, cCount) + __ret := C.dispatch_nvmlGpuInstanceGetComputeInstanceRemainingCapacity(cnvmlGpuInstance, cProfileId, cCount) __v := (Return)(__ret) return __v } @@ -3264,7 +3263,7 @@ func nvmlGpuInstanceGetComputeInstancePossiblePlacements(nvmlGpuInstance nvmlGpu cProfileId, _ := (C.uint)(ProfileId), cgoAllocsUnknown cPlacements, _ := (*C.nvmlComputeInstancePlacement_t)(unsafe.Pointer(Placements)), cgoAllocsUnknown cCount, _ := (*C.uint)(unsafe.Pointer(Count)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceGetComputeInstancePossiblePlacements(cnvmlGpuInstance, cProfileId, cPlacements, cCount) + __ret := C.dispatch_nvmlGpuInstanceGetComputeInstancePossiblePlacements(cnvmlGpuInstance, cProfileId, cPlacements, cCount) __v := (Return)(__ret) return __v } @@ -3274,7 +3273,7 @@ func nvmlGpuInstanceCreateComputeInstance(nvmlGpuInstance nvmlGpuInstance, Profi cnvmlGpuInstance, _ := *(*C.nvmlGpuInstance_t)(unsafe.Pointer(&nvmlGpuInstance)), cgoAllocsUnknown cProfileId, _ := (C.uint)(ProfileId), cgoAllocsUnknown cnvmlComputeInstance, _ := (*C.nvmlComputeInstance_t)(unsafe.Pointer(nvmlComputeInstance)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceCreateComputeInstance(cnvmlGpuInstance, cProfileId, cnvmlComputeInstance) + __ret := C.dispatch_nvmlGpuInstanceCreateComputeInstance(cnvmlGpuInstance, cProfileId, cnvmlComputeInstance) __v := (Return)(__ret) return __v } @@ -3285,7 +3284,7 @@ func nvmlGpuInstanceCreateComputeInstanceWithPlacement(nvmlGpuInstance nvmlGpuIn cProfileId, _ := (C.uint)(ProfileId), cgoAllocsUnknown cPlacement, _ := (*C.nvmlComputeInstancePlacement_t)(unsafe.Pointer(Placement)), cgoAllocsUnknown cnvmlComputeInstance, _ := (*C.nvmlComputeInstance_t)(unsafe.Pointer(nvmlComputeInstance)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceCreateComputeInstanceWithPlacement(cnvmlGpuInstance, cProfileId, cPlacement, cnvmlComputeInstance) + __ret := C.dispatch_nvmlGpuInstanceCreateComputeInstanceWithPlacement(cnvmlGpuInstance, cProfileId, cPlacement, cnvmlComputeInstance) __v := (Return)(__ret) return __v } @@ -3293,7 +3292,7 @@ func nvmlGpuInstanceCreateComputeInstanceWithPlacement(nvmlGpuInstance nvmlGpuIn // nvmlComputeInstanceDestroy function as declared in nvml/nvml.h func nvmlComputeInstanceDestroy(nvmlComputeInstance nvmlComputeInstance) Return { cnvmlComputeInstance, _ := *(*C.nvmlComputeInstance_t)(unsafe.Pointer(&nvmlComputeInstance)), cgoAllocsUnknown - __ret := C.nvmlComputeInstanceDestroy(cnvmlComputeInstance) + __ret := C.dispatch_nvmlComputeInstanceDestroy(cnvmlComputeInstance) __v := (Return)(__ret) return __v } @@ -3304,7 +3303,7 @@ func nvmlGpuInstanceGetComputeInstances(nvmlGpuInstance nvmlGpuInstance, Profile cProfileId, _ := (C.uint)(ProfileId), cgoAllocsUnknown cComputeInstances, _ := (*C.nvmlComputeInstance_t)(unsafe.Pointer(ComputeInstances)), cgoAllocsUnknown cCount, _ := (*C.uint)(unsafe.Pointer(Count)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceGetComputeInstances(cnvmlGpuInstance, cProfileId, cComputeInstances, cCount) + __ret := C.dispatch_nvmlGpuInstanceGetComputeInstances(cnvmlGpuInstance, cProfileId, cComputeInstances, cCount) __v := (Return)(__ret) return __v } @@ -3314,7 +3313,7 @@ func nvmlGpuInstanceGetComputeInstanceById(nvmlGpuInstance nvmlGpuInstance, Id u cnvmlGpuInstance, _ := *(*C.nvmlGpuInstance_t)(unsafe.Pointer(&nvmlGpuInstance)), cgoAllocsUnknown cId, _ := (C.uint)(Id), cgoAllocsUnknown cnvmlComputeInstance, _ := (*C.nvmlComputeInstance_t)(unsafe.Pointer(nvmlComputeInstance)), cgoAllocsUnknown - __ret := C.nvmlGpuInstanceGetComputeInstanceById(cnvmlGpuInstance, cId, cnvmlComputeInstance) + __ret := C.dispatch_nvmlGpuInstanceGetComputeInstanceById(cnvmlGpuInstance, cId, cnvmlComputeInstance) __v := (Return)(__ret) return __v } @@ -3323,7 +3322,7 @@ func nvmlGpuInstanceGetComputeInstanceById(nvmlGpuInstance nvmlGpuInstance, Id u func nvmlComputeInstanceGetInfo_v2(nvmlComputeInstance nvmlComputeInstance, Info *nvmlComputeInstanceInfo) Return { cnvmlComputeInstance, _ := *(*C.nvmlComputeInstance_t)(unsafe.Pointer(&nvmlComputeInstance)), cgoAllocsUnknown cInfo, _ := (*C.nvmlComputeInstanceInfo_t)(unsafe.Pointer(Info)), cgoAllocsUnknown - __ret := C.nvmlComputeInstanceGetInfo_v2(cnvmlComputeInstance, cInfo) + __ret := C.dispatch_nvmlComputeInstanceGetInfo_v2(cnvmlComputeInstance, cInfo) __v := (Return)(__ret) return __v } @@ -3332,7 +3331,7 @@ func nvmlComputeInstanceGetInfo_v2(nvmlComputeInstance nvmlComputeInstance, Info func nvmlDeviceIsMigDeviceHandle(nvmlDevice nvmlDevice, IsMigDevice *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cIsMigDevice, _ := (*C.uint)(unsafe.Pointer(IsMigDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceIsMigDeviceHandle(cnvmlDevice, cIsMigDevice) + __ret := C.dispatch_nvmlDeviceIsMigDeviceHandle(cnvmlDevice, cIsMigDevice) __v := (Return)(__ret) return __v } @@ -3341,7 +3340,7 @@ func nvmlDeviceIsMigDeviceHandle(nvmlDevice nvmlDevice, IsMigDevice *uint32) Ret func nvmlDeviceGetGpuInstanceId(nvmlDevice nvmlDevice, Id *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cId, _ := (*C.uint)(unsafe.Pointer(Id)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpuInstanceId(cnvmlDevice, cId) + __ret := C.dispatch_nvmlDeviceGetGpuInstanceId(cnvmlDevice, cId) __v := (Return)(__ret) return __v } @@ -3350,7 +3349,7 @@ func nvmlDeviceGetGpuInstanceId(nvmlDevice nvmlDevice, Id *uint32) Return { func nvmlDeviceGetComputeInstanceId(nvmlDevice nvmlDevice, Id *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cId, _ := (*C.uint)(unsafe.Pointer(Id)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetComputeInstanceId(cnvmlDevice, cId) + __ret := C.dispatch_nvmlDeviceGetComputeInstanceId(cnvmlDevice, cId) __v := (Return)(__ret) return __v } @@ -3359,7 +3358,7 @@ func nvmlDeviceGetComputeInstanceId(nvmlDevice nvmlDevice, Id *uint32) Return { func nvmlDeviceGetMaxMigDeviceCount(nvmlDevice nvmlDevice, Count *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCount, _ := (*C.uint)(unsafe.Pointer(Count)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMaxMigDeviceCount(cnvmlDevice, cCount) + __ret := C.dispatch_nvmlDeviceGetMaxMigDeviceCount(cnvmlDevice, cCount) __v := (Return)(__ret) return __v } @@ -3369,7 +3368,7 @@ func nvmlDeviceGetMigDeviceHandleByIndex(nvmlDevice nvmlDevice, Index uint32, Mi cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cIndex, _ := (C.uint)(Index), cgoAllocsUnknown cMigDevice, _ := (*C.nvmlDevice_t)(unsafe.Pointer(MigDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMigDeviceHandleByIndex(cnvmlDevice, cIndex, cMigDevice) + __ret := C.dispatch_nvmlDeviceGetMigDeviceHandleByIndex(cnvmlDevice, cIndex, cMigDevice) __v := (Return)(__ret) return __v } @@ -3378,7 +3377,7 @@ func nvmlDeviceGetMigDeviceHandleByIndex(nvmlDevice nvmlDevice, Index uint32, Mi func nvmlDeviceGetDeviceHandleFromMigDeviceHandle(MigDevice nvmlDevice, nvmlDevice *nvmlDevice) Return { cMigDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&MigDevice)), cgoAllocsUnknown cnvmlDevice, _ := (*C.nvmlDevice_t)(unsafe.Pointer(nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetDeviceHandleFromMigDeviceHandle(cMigDevice, cnvmlDevice) + __ret := C.dispatch_nvmlDeviceGetDeviceHandleFromMigDeviceHandle(cMigDevice, cnvmlDevice) __v := (Return)(__ret) return __v } @@ -3386,7 +3385,7 @@ func nvmlDeviceGetDeviceHandleFromMigDeviceHandle(MigDevice nvmlDevice, nvmlDevi // nvmlGpmMetricsGet function as declared in nvml/nvml.h func nvmlGpmMetricsGet(MetricsGet *nvmlGpmMetricsGetType) Return { cMetricsGet, _ := (*C.nvmlGpmMetricsGet_t)(unsafe.Pointer(MetricsGet)), cgoAllocsUnknown - __ret := C.nvmlGpmMetricsGet(cMetricsGet) + __ret := C.dispatch_nvmlGpmMetricsGet(cMetricsGet) __v := (Return)(__ret) return __v } @@ -3394,7 +3393,7 @@ func nvmlGpmMetricsGet(MetricsGet *nvmlGpmMetricsGetType) Return { // nvmlGpmSampleFree function as declared in nvml/nvml.h func nvmlGpmSampleFree(nvmlGpmSample nvmlGpmSample) Return { cnvmlGpmSample, _ := *(*C.nvmlGpmSample_t)(unsafe.Pointer(&nvmlGpmSample)), cgoAllocsUnknown - __ret := C.nvmlGpmSampleFree(cnvmlGpmSample) + __ret := C.dispatch_nvmlGpmSampleFree(cnvmlGpmSample) __v := (Return)(__ret) return __v } @@ -3402,7 +3401,7 @@ func nvmlGpmSampleFree(nvmlGpmSample nvmlGpmSample) Return { // nvmlGpmSampleAlloc function as declared in nvml/nvml.h func nvmlGpmSampleAlloc(nvmlGpmSample *nvmlGpmSample) Return { cnvmlGpmSample, _ := (*C.nvmlGpmSample_t)(unsafe.Pointer(nvmlGpmSample)), cgoAllocsUnknown - __ret := C.nvmlGpmSampleAlloc(cnvmlGpmSample) + __ret := C.dispatch_nvmlGpmSampleAlloc(cnvmlGpmSample) __v := (Return)(__ret) return __v } @@ -3411,7 +3410,7 @@ func nvmlGpmSampleAlloc(nvmlGpmSample *nvmlGpmSample) Return { func nvmlGpmSampleGet(nvmlDevice nvmlDevice, nvmlGpmSample nvmlGpmSample) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cnvmlGpmSample, _ := *(*C.nvmlGpmSample_t)(unsafe.Pointer(&nvmlGpmSample)), cgoAllocsUnknown - __ret := C.nvmlGpmSampleGet(cnvmlDevice, cnvmlGpmSample) + __ret := C.dispatch_nvmlGpmSampleGet(cnvmlDevice, cnvmlGpmSample) __v := (Return)(__ret) return __v } @@ -3421,7 +3420,7 @@ func nvmlGpmMigSampleGet(nvmlDevice nvmlDevice, GpuInstanceId uint32, nvmlGpmSam cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cGpuInstanceId, _ := (C.uint)(GpuInstanceId), cgoAllocsUnknown cnvmlGpmSample, _ := *(*C.nvmlGpmSample_t)(unsafe.Pointer(&nvmlGpmSample)), cgoAllocsUnknown - __ret := C.nvmlGpmMigSampleGet(cnvmlDevice, cGpuInstanceId, cnvmlGpmSample) + __ret := C.dispatch_nvmlGpmMigSampleGet(cnvmlDevice, cGpuInstanceId, cnvmlGpmSample) __v := (Return)(__ret) return __v } @@ -3430,7 +3429,7 @@ func nvmlGpmMigSampleGet(nvmlDevice nvmlDevice, GpuInstanceId uint32, nvmlGpmSam func nvmlGpmQueryDeviceSupport(nvmlDevice nvmlDevice, GpmSupport *GpmSupport) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cGpmSupport, _ := (*C.nvmlGpmSupport_t)(unsafe.Pointer(GpmSupport)), cgoAllocsUnknown - __ret := C.nvmlGpmQueryDeviceSupport(cnvmlDevice, cGpmSupport) + __ret := C.dispatch_nvmlGpmQueryDeviceSupport(cnvmlDevice, cGpmSupport) __v := (Return)(__ret) return __v } @@ -3439,7 +3438,7 @@ func nvmlGpmQueryDeviceSupport(nvmlDevice nvmlDevice, GpmSupport *GpmSupport) Re func nvmlGpmQueryIfStreamingEnabled(nvmlDevice nvmlDevice, State *uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cState, _ := (*C.uint)(unsafe.Pointer(State)), cgoAllocsUnknown - __ret := C.nvmlGpmQueryIfStreamingEnabled(cnvmlDevice, cState) + __ret := C.dispatch_nvmlGpmQueryIfStreamingEnabled(cnvmlDevice, cState) __v := (Return)(__ret) return __v } @@ -3448,7 +3447,7 @@ func nvmlGpmQueryIfStreamingEnabled(nvmlDevice nvmlDevice, State *uint32) Return func nvmlGpmSetStreamingEnabled(nvmlDevice nvmlDevice, State uint32) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cState, _ := (C.uint)(State), cgoAllocsUnknown - __ret := C.nvmlGpmSetStreamingEnabled(cnvmlDevice, cState) + __ret := C.dispatch_nvmlGpmSetStreamingEnabled(cnvmlDevice, cState) __v := (Return)(__ret) return __v } @@ -3457,7 +3456,7 @@ func nvmlGpmSetStreamingEnabled(nvmlDevice nvmlDevice, State uint32) Return { func nvmlDeviceGetCapabilities(nvmlDevice nvmlDevice, Caps *DeviceCapabilities) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCaps, _ := (*C.nvmlDeviceCapabilities_t)(unsafe.Pointer(Caps)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetCapabilities(cnvmlDevice, cCaps) + __ret := C.dispatch_nvmlDeviceGetCapabilities(cnvmlDevice, cCaps) __v := (Return)(__ret) return __v } @@ -3466,7 +3465,7 @@ func nvmlDeviceGetCapabilities(nvmlDevice nvmlDevice, Caps *DeviceCapabilities) func nvmlDeviceWorkloadPowerProfileGetProfilesInfo(nvmlDevice nvmlDevice, ProfilesInfo *WorkloadPowerProfileProfilesInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cProfilesInfo, _ := (*C.nvmlWorkloadPowerProfileProfilesInfo_t)(unsafe.Pointer(ProfilesInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceWorkloadPowerProfileGetProfilesInfo(cnvmlDevice, cProfilesInfo) + __ret := C.dispatch_nvmlDeviceWorkloadPowerProfileGetProfilesInfo(cnvmlDevice, cProfilesInfo) __v := (Return)(__ret) return __v } @@ -3475,7 +3474,7 @@ func nvmlDeviceWorkloadPowerProfileGetProfilesInfo(nvmlDevice nvmlDevice, Profil func nvmlDeviceWorkloadPowerProfileGetCurrentProfiles(nvmlDevice nvmlDevice, CurrentProfiles *WorkloadPowerProfileCurrentProfiles) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCurrentProfiles, _ := (*C.nvmlWorkloadPowerProfileCurrentProfiles_t)(unsafe.Pointer(CurrentProfiles)), cgoAllocsUnknown - __ret := C.nvmlDeviceWorkloadPowerProfileGetCurrentProfiles(cnvmlDevice, cCurrentProfiles) + __ret := C.dispatch_nvmlDeviceWorkloadPowerProfileGetCurrentProfiles(cnvmlDevice, cCurrentProfiles) __v := (Return)(__ret) return __v } @@ -3484,7 +3483,7 @@ func nvmlDeviceWorkloadPowerProfileGetCurrentProfiles(nvmlDevice nvmlDevice, Cur func nvmlDeviceWorkloadPowerProfileSetRequestedProfiles(nvmlDevice nvmlDevice, RequestedProfiles *WorkloadPowerProfileRequestedProfiles) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cRequestedProfiles, _ := (*C.nvmlWorkloadPowerProfileRequestedProfiles_t)(unsafe.Pointer(RequestedProfiles)), cgoAllocsUnknown - __ret := C.nvmlDeviceWorkloadPowerProfileSetRequestedProfiles(cnvmlDevice, cRequestedProfiles) + __ret := C.dispatch_nvmlDeviceWorkloadPowerProfileSetRequestedProfiles(cnvmlDevice, cRequestedProfiles) __v := (Return)(__ret) return __v } @@ -3493,7 +3492,7 @@ func nvmlDeviceWorkloadPowerProfileSetRequestedProfiles(nvmlDevice nvmlDevice, R func nvmlDeviceWorkloadPowerProfileClearRequestedProfiles(nvmlDevice nvmlDevice, RequestedProfiles *WorkloadPowerProfileRequestedProfiles) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cRequestedProfiles, _ := (*C.nvmlWorkloadPowerProfileRequestedProfiles_t)(unsafe.Pointer(RequestedProfiles)), cgoAllocsUnknown - __ret := C.nvmlDeviceWorkloadPowerProfileClearRequestedProfiles(cnvmlDevice, cRequestedProfiles) + __ret := C.dispatch_nvmlDeviceWorkloadPowerProfileClearRequestedProfiles(cnvmlDevice, cRequestedProfiles) __v := (Return)(__ret) return __v } @@ -3502,7 +3501,7 @@ func nvmlDeviceWorkloadPowerProfileClearRequestedProfiles(nvmlDevice nvmlDevice, func nvmlDevicePowerSmoothingActivatePresetProfile(nvmlDevice nvmlDevice, Profile *PowerSmoothingProfile) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cProfile, _ := (*C.nvmlPowerSmoothingProfile_t)(unsafe.Pointer(Profile)), cgoAllocsUnknown - __ret := C.nvmlDevicePowerSmoothingActivatePresetProfile(cnvmlDevice, cProfile) + __ret := C.dispatch_nvmlDevicePowerSmoothingActivatePresetProfile(cnvmlDevice, cProfile) __v := (Return)(__ret) return __v } @@ -3511,7 +3510,7 @@ func nvmlDevicePowerSmoothingActivatePresetProfile(nvmlDevice nvmlDevice, Profil func nvmlDevicePowerSmoothingUpdatePresetProfileParam(nvmlDevice nvmlDevice, Profile *PowerSmoothingProfile) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cProfile, _ := (*C.nvmlPowerSmoothingProfile_t)(unsafe.Pointer(Profile)), cgoAllocsUnknown - __ret := C.nvmlDevicePowerSmoothingUpdatePresetProfileParam(cnvmlDevice, cProfile) + __ret := C.dispatch_nvmlDevicePowerSmoothingUpdatePresetProfileParam(cnvmlDevice, cProfile) __v := (Return)(__ret) return __v } @@ -3520,7 +3519,7 @@ func nvmlDevicePowerSmoothingUpdatePresetProfileParam(nvmlDevice nvmlDevice, Pro func nvmlDevicePowerSmoothingSetState(nvmlDevice nvmlDevice, State *PowerSmoothingState) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cState, _ := (*C.nvmlPowerSmoothingState_t)(unsafe.Pointer(State)), cgoAllocsUnknown - __ret := C.nvmlDevicePowerSmoothingSetState(cnvmlDevice, cState) + __ret := C.dispatch_nvmlDevicePowerSmoothingSetState(cnvmlDevice, cState) __v := (Return)(__ret) return __v } @@ -3529,14 +3528,14 @@ func nvmlDevicePowerSmoothingSetState(nvmlDevice nvmlDevice, State *PowerSmoothi func nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts(nvmlDevice nvmlDevice, ErrorCounts *EccSramUniqueUncorrectedErrorCounts) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cErrorCounts, _ := (*C.nvmlEccSramUniqueUncorrectedErrorCounts_t)(unsafe.Pointer(ErrorCounts)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts(cnvmlDevice, cErrorCounts) + __ret := C.dispatch_nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts(cnvmlDevice, cErrorCounts) __v := (Return)(__ret) return __v } // nvmlInit_v1 function as declared in nvml/nvml.h func nvmlInit_v1() Return { - __ret := C.nvmlInit() + __ret := C.dispatch_nvmlInit() __v := (Return)(__ret) return __v } @@ -3544,7 +3543,7 @@ func nvmlInit_v1() Return { // nvmlDeviceGetCount_v1 function as declared in nvml/nvml.h func nvmlDeviceGetCount_v1(DeviceCount *uint32) Return { cDeviceCount, _ := (*C.uint)(unsafe.Pointer(DeviceCount)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetCount(cDeviceCount) + __ret := C.dispatch_nvmlDeviceGetCount(cDeviceCount) __v := (Return)(__ret) return __v } @@ -3553,7 +3552,7 @@ func nvmlDeviceGetCount_v1(DeviceCount *uint32) Return { func nvmlDeviceGetHandleByIndex_v1(Index uint32, nvmlDevice *nvmlDevice) Return { cIndex, _ := (C.uint)(Index), cgoAllocsUnknown cnvmlDevice, _ := (*C.nvmlDevice_t)(unsafe.Pointer(nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetHandleByIndex(cIndex, cnvmlDevice) + __ret := C.dispatch_nvmlDeviceGetHandleByIndex(cIndex, cnvmlDevice) __v := (Return)(__ret) return __v } @@ -3562,7 +3561,7 @@ func nvmlDeviceGetHandleByIndex_v1(Index uint32, nvmlDevice *nvmlDevice) Return func nvmlDeviceGetHandleByPciBusId_v1(PciBusId string, nvmlDevice *nvmlDevice) Return { cPciBusId, _ := unpackPCharString(PciBusId) cnvmlDevice, _ := (*C.nvmlDevice_t)(unsafe.Pointer(nvmlDevice)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetHandleByPciBusId(cPciBusId, cnvmlDevice) + __ret := C.dispatch_nvmlDeviceGetHandleByPciBusId(cPciBusId, cnvmlDevice) __v := (Return)(__ret) return __v } @@ -3571,7 +3570,7 @@ func nvmlDeviceGetHandleByPciBusId_v1(PciBusId string, nvmlDevice *nvmlDevice) R func nvmlDeviceGetPciInfo_v1(nvmlDevice nvmlDevice, Pci *PciInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPci, _ := (*C.nvmlPciInfo_t)(unsafe.Pointer(Pci)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPciInfo(cnvmlDevice, cPci) + __ret := C.dispatch_nvmlDeviceGetPciInfo(cnvmlDevice, cPci) __v := (Return)(__ret) return __v } @@ -3580,7 +3579,7 @@ func nvmlDeviceGetPciInfo_v1(nvmlDevice nvmlDevice, Pci *PciInfo) Return { func nvmlDeviceGetPciInfo_v2(nvmlDevice nvmlDevice, Pci *PciInfo) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPci, _ := (*C.nvmlPciInfo_t)(unsafe.Pointer(Pci)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetPciInfo_v2(cnvmlDevice, cPci) + __ret := C.dispatch_nvmlDeviceGetPciInfo_v2(cnvmlDevice, cPci) __v := (Return)(__ret) return __v } @@ -3590,7 +3589,7 @@ func nvmlDeviceGetNvLinkRemotePciInfo_v1(nvmlDevice nvmlDevice, Link uint32, Pci cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cLink, _ := (C.uint)(Link), cgoAllocsUnknown cPci, _ := (*C.nvmlPciInfo_t)(unsafe.Pointer(Pci)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetNvLinkRemotePciInfo(cnvmlDevice, cLink, cPci) + __ret := C.dispatch_nvmlDeviceGetNvLinkRemotePciInfo(cnvmlDevice, cLink, cPci) __v := (Return)(__ret) return __v } @@ -3599,7 +3598,7 @@ func nvmlDeviceGetNvLinkRemotePciInfo_v1(nvmlDevice nvmlDevice, Link uint32, Pci func nvmlDeviceGetGridLicensableFeatures_v1(nvmlDevice nvmlDevice, PGridLicensableFeatures *GridLicensableFeatures) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPGridLicensableFeatures, _ := (*C.nvmlGridLicensableFeatures_t)(unsafe.Pointer(PGridLicensableFeatures)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGridLicensableFeatures(cnvmlDevice, cPGridLicensableFeatures) + __ret := C.dispatch_nvmlDeviceGetGridLicensableFeatures(cnvmlDevice, cPGridLicensableFeatures) __v := (Return)(__ret) return __v } @@ -3608,7 +3607,7 @@ func nvmlDeviceGetGridLicensableFeatures_v1(nvmlDevice nvmlDevice, PGridLicensab func nvmlDeviceGetGridLicensableFeatures_v2(nvmlDevice nvmlDevice, PGridLicensableFeatures *GridLicensableFeatures) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPGridLicensableFeatures, _ := (*C.nvmlGridLicensableFeatures_t)(unsafe.Pointer(PGridLicensableFeatures)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGridLicensableFeatures_v2(cnvmlDevice, cPGridLicensableFeatures) + __ret := C.dispatch_nvmlDeviceGetGridLicensableFeatures_v2(cnvmlDevice, cPGridLicensableFeatures) __v := (Return)(__ret) return __v } @@ -3617,7 +3616,7 @@ func nvmlDeviceGetGridLicensableFeatures_v2(nvmlDevice nvmlDevice, PGridLicensab func nvmlDeviceGetGridLicensableFeatures_v3(nvmlDevice nvmlDevice, PGridLicensableFeatures *GridLicensableFeatures) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cPGridLicensableFeatures, _ := (*C.nvmlGridLicensableFeatures_t)(unsafe.Pointer(PGridLicensableFeatures)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGridLicensableFeatures_v3(cnvmlDevice, cPGridLicensableFeatures) + __ret := C.dispatch_nvmlDeviceGetGridLicensableFeatures_v3(cnvmlDevice, cPGridLicensableFeatures) __v := (Return)(__ret) return __v } @@ -3625,7 +3624,7 @@ func nvmlDeviceGetGridLicensableFeatures_v3(nvmlDevice nvmlDevice, PGridLicensab // nvmlDeviceRemoveGpu_v1 function as declared in nvml/nvml.h func nvmlDeviceRemoveGpu_v1(PciInfo *PciInfo) Return { cPciInfo, _ := (*C.nvmlPciInfo_t)(unsafe.Pointer(PciInfo)), cgoAllocsUnknown - __ret := C.nvmlDeviceRemoveGpu(cPciInfo) + __ret := C.dispatch_nvmlDeviceRemoveGpu(cPciInfo) __v := (Return)(__ret) return __v } @@ -3635,7 +3634,7 @@ func nvmlEventSetWait_v1(Set nvmlEventSet, Data *nvmlEventData, Timeoutms uint32 cSet, _ := *(*C.nvmlEventSet_t)(unsafe.Pointer(&Set)), cgoAllocsUnknown cData, _ := (*C.nvmlEventData_t)(unsafe.Pointer(Data)), cgoAllocsUnknown cTimeoutms, _ := (C.uint)(Timeoutms), cgoAllocsUnknown - __ret := C.nvmlEventSetWait(cSet, cData, cTimeoutms) + __ret := C.dispatch_nvmlEventSetWait(cSet, cData, cTimeoutms) __v := (Return)(__ret) return __v } @@ -3644,7 +3643,7 @@ func nvmlEventSetWait_v1(Set nvmlEventSet, Data *nvmlEventData, Timeoutms uint32 func nvmlDeviceGetAttributes_v1(nvmlDevice nvmlDevice, Attributes *DeviceAttributes) Return { cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cAttributes, _ := (*C.nvmlDeviceAttributes_t)(unsafe.Pointer(Attributes)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetAttributes(cnvmlDevice, cAttributes) + __ret := C.dispatch_nvmlDeviceGetAttributes(cnvmlDevice, cAttributes) __v := (Return)(__ret) return __v } @@ -3653,7 +3652,7 @@ func nvmlDeviceGetAttributes_v1(nvmlDevice nvmlDevice, Attributes *DeviceAttribu func nvmlComputeInstanceGetInfo_v1(nvmlComputeInstance nvmlComputeInstance, Info *nvmlComputeInstanceInfo) Return { cnvmlComputeInstance, _ := *(*C.nvmlComputeInstance_t)(unsafe.Pointer(&nvmlComputeInstance)), cgoAllocsUnknown cInfo, _ := (*C.nvmlComputeInstanceInfo_t)(unsafe.Pointer(Info)), cgoAllocsUnknown - __ret := C.nvmlComputeInstanceGetInfo(cnvmlComputeInstance, cInfo) + __ret := C.dispatch_nvmlComputeInstanceGetInfo(cnvmlComputeInstance, cInfo) __v := (Return)(__ret) return __v } @@ -3663,7 +3662,7 @@ func nvmlDeviceGetComputeRunningProcesses_v1(nvmlDevice nvmlDevice, InfoCount *u cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cInfoCount, _ := (*C.uint)(unsafe.Pointer(InfoCount)), cgoAllocsUnknown cInfos, _ := (*C.nvmlProcessInfo_v1_t)(unsafe.Pointer(Infos)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetComputeRunningProcesses(cnvmlDevice, cInfoCount, cInfos) + __ret := C.dispatch_nvmlDeviceGetComputeRunningProcesses(cnvmlDevice, cInfoCount, cInfos) __v := (Return)(__ret) return __v } @@ -3673,7 +3672,7 @@ func nvmlDeviceGetComputeRunningProcesses_v2(nvmlDevice nvmlDevice, InfoCount *u cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cInfoCount, _ := (*C.uint)(unsafe.Pointer(InfoCount)), cgoAllocsUnknown cInfos, _ := (*C.nvmlProcessInfo_v2_t)(unsafe.Pointer(Infos)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetComputeRunningProcesses_v2(cnvmlDevice, cInfoCount, cInfos) + __ret := C.dispatch_nvmlDeviceGetComputeRunningProcesses_v2(cnvmlDevice, cInfoCount, cInfos) __v := (Return)(__ret) return __v } @@ -3683,7 +3682,7 @@ func nvmlDeviceGetGraphicsRunningProcesses_v1(nvmlDevice nvmlDevice, InfoCount * cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cInfoCount, _ := (*C.uint)(unsafe.Pointer(InfoCount)), cgoAllocsUnknown cInfos, _ := (*C.nvmlProcessInfo_v1_t)(unsafe.Pointer(Infos)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGraphicsRunningProcesses(cnvmlDevice, cInfoCount, cInfos) + __ret := C.dispatch_nvmlDeviceGetGraphicsRunningProcesses(cnvmlDevice, cInfoCount, cInfos) __v := (Return)(__ret) return __v } @@ -3693,7 +3692,7 @@ func nvmlDeviceGetGraphicsRunningProcesses_v2(nvmlDevice nvmlDevice, InfoCount * cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cInfoCount, _ := (*C.uint)(unsafe.Pointer(InfoCount)), cgoAllocsUnknown cInfos, _ := (*C.nvmlProcessInfo_v2_t)(unsafe.Pointer(Infos)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGraphicsRunningProcesses_v2(cnvmlDevice, cInfoCount, cInfos) + __ret := C.dispatch_nvmlDeviceGetGraphicsRunningProcesses_v2(cnvmlDevice, cInfoCount, cInfos) __v := (Return)(__ret) return __v } @@ -3703,7 +3702,7 @@ func nvmlDeviceGetMPSComputeRunningProcesses_v1(nvmlDevice nvmlDevice, InfoCount cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cInfoCount, _ := (*C.uint)(unsafe.Pointer(InfoCount)), cgoAllocsUnknown cInfos, _ := (*C.nvmlProcessInfo_v1_t)(unsafe.Pointer(Infos)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMPSComputeRunningProcesses(cnvmlDevice, cInfoCount, cInfos) + __ret := C.dispatch_nvmlDeviceGetMPSComputeRunningProcesses(cnvmlDevice, cInfoCount, cInfos) __v := (Return)(__ret) return __v } @@ -3713,7 +3712,7 @@ func nvmlDeviceGetMPSComputeRunningProcesses_v2(nvmlDevice nvmlDevice, InfoCount cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cInfoCount, _ := (*C.uint)(unsafe.Pointer(InfoCount)), cgoAllocsUnknown cInfos, _ := (*C.nvmlProcessInfo_v2_t)(unsafe.Pointer(Infos)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetMPSComputeRunningProcesses_v2(cnvmlDevice, cInfoCount, cInfos) + __ret := C.dispatch_nvmlDeviceGetMPSComputeRunningProcesses_v2(cnvmlDevice, cInfoCount, cInfos) __v := (Return)(__ret) return __v } @@ -3724,7 +3723,7 @@ func nvmlDeviceGetGpuInstancePossiblePlacements_v1(nvmlDevice nvmlDevice, Profil cProfileId, _ := (C.uint)(ProfileId), cgoAllocsUnknown cPlacements, _ := (*C.nvmlGpuInstancePlacement_t)(unsafe.Pointer(Placements)), cgoAllocsUnknown cCount, _ := (*C.uint)(unsafe.Pointer(Count)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetGpuInstancePossiblePlacements(cnvmlDevice, cProfileId, cPlacements, cCount) + __ret := C.dispatch_nvmlDeviceGetGpuInstancePossiblePlacements(cnvmlDevice, cProfileId, cPlacements, cCount) __v := (Return)(__ret) return __v } @@ -3733,7 +3732,7 @@ func nvmlDeviceGetGpuInstancePossiblePlacements_v1(nvmlDevice nvmlDevice, Profil func nvmlVgpuInstanceGetLicenseInfo_v1(nvmlVgpuInstance nvmlVgpuInstance, LicenseInfo *VgpuLicenseInfo) Return { cnvmlVgpuInstance, _ := (C.nvmlVgpuInstance_t)(nvmlVgpuInstance), cgoAllocsUnknown cLicenseInfo, _ := (*C.nvmlVgpuLicenseInfo_t)(unsafe.Pointer(LicenseInfo)), cgoAllocsUnknown - __ret := C.nvmlVgpuInstanceGetLicenseInfo(cnvmlVgpuInstance, cLicenseInfo) + __ret := C.dispatch_nvmlVgpuInstanceGetLicenseInfo(cnvmlVgpuInstance, cLicenseInfo) __v := (Return)(__ret) return __v } @@ -3743,7 +3742,7 @@ func nvmlDeviceGetDriverModel_v1(nvmlDevice nvmlDevice, Current *DriverModel, Pe cnvmlDevice, _ := *(*C.nvmlDevice_t)(unsafe.Pointer(&nvmlDevice)), cgoAllocsUnknown cCurrent, _ := (*C.nvmlDriverModel_t)(unsafe.Pointer(Current)), cgoAllocsUnknown cPending, _ := (*C.nvmlDriverModel_t)(unsafe.Pointer(Pending)), cgoAllocsUnknown - __ret := C.nvmlDeviceGetDriverModel(cnvmlDevice, cCurrent, cPending) + __ret := C.dispatch_nvmlDeviceGetDriverModel(cnvmlDevice, cCurrent, cPending) __v := (Return)(__ret) return __v } diff --git a/pkg/nvml/nvml_dispatch.h b/pkg/nvml/nvml_dispatch.h new file mode 100644 index 00000000..b4e5f41f --- /dev/null +++ b/pkg/nvml/nvml_dispatch.h @@ -0,0 +1,2410 @@ +// Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// WARNING: THIS FILE WAS AUTOMATICALLY GENERATED. +// Code generated by gen/nvml/gen-dispatch. DO NOT EDIT. + +#ifndef NVML_DISPATCH_H +#define NVML_DISPATCH_H + +#include "nvml.h" + +// nvml_dispatch_t holds function pointers for all NVML API functions. +// Populated at library load time via populateDispatch() in Go. +typedef struct { + nvmlReturn_t (*nvmlInit_v2)(void); + nvmlReturn_t (*nvmlInitWithFlags)(unsigned int flags); + nvmlReturn_t (*nvmlShutdown)(void); + const char* (*nvmlErrorString)(nvmlReturn_t result); + nvmlReturn_t (*nvmlSystemGetDriverVersion)(char * version, unsigned int length); + nvmlReturn_t (*nvmlSystemGetNVMLVersion)(char * version, unsigned int length); + nvmlReturn_t (*nvmlSystemGetCudaDriverVersion)(int * cudaDriverVersion); + nvmlReturn_t (*nvmlSystemGetCudaDriverVersion_v2)(int * cudaDriverVersion); + nvmlReturn_t (*nvmlSystemGetProcessName)(unsigned int pid, char * name, unsigned int length); + nvmlReturn_t (*nvmlSystemGetHicVersion)(unsigned int * hwbcCount, nvmlHwbcEntry_t * hwbcEntries); + nvmlReturn_t (*nvmlSystemGetTopologyGpuSet)(unsigned int cpuNumber, unsigned int * count, nvmlDevice_t * deviceArray); + nvmlReturn_t (*nvmlSystemGetDriverBranch)(nvmlSystemDriverBranchInfo_t * branchInfo, unsigned int length); + nvmlReturn_t (*nvmlUnitGetCount)(unsigned int * unitCount); + nvmlReturn_t (*nvmlUnitGetHandleByIndex)(unsigned int index, nvmlUnit_t * unit); + nvmlReturn_t (*nvmlUnitGetUnitInfo)(nvmlUnit_t unit, nvmlUnitInfo_t * info); + nvmlReturn_t (*nvmlUnitGetLedState)(nvmlUnit_t unit, nvmlLedState_t * state); + nvmlReturn_t (*nvmlUnitGetPsuInfo)(nvmlUnit_t unit, nvmlPSUInfo_t * psu); + nvmlReturn_t (*nvmlUnitGetTemperature)(nvmlUnit_t unit, unsigned int type, unsigned int * temp); + nvmlReturn_t (*nvmlUnitGetFanSpeedInfo)(nvmlUnit_t unit, nvmlUnitFanSpeeds_t * fanSpeeds); + nvmlReturn_t (*nvmlUnitGetDevices)(nvmlUnit_t unit, unsigned int * deviceCount, nvmlDevice_t * devices); + nvmlReturn_t (*nvmlDeviceGetCount_v2)(unsigned int * deviceCount); + nvmlReturn_t (*nvmlDeviceGetAttributes_v2)(nvmlDevice_t device, nvmlDeviceAttributes_t * attributes); + nvmlReturn_t (*nvmlDeviceGetHandleByIndex_v2)(unsigned int index, nvmlDevice_t * device); + nvmlReturn_t (*nvmlDeviceGetHandleBySerial)(const char * serial, nvmlDevice_t * device); + nvmlReturn_t (*nvmlDeviceGetHandleByUUID)(const char * uuid, nvmlDevice_t * device); + nvmlReturn_t (*nvmlDeviceGetHandleByUUIDV)(const nvmlUUID_t * uuid, nvmlDevice_t * device); + nvmlReturn_t (*nvmlDeviceGetHandleByPciBusId_v2)(const char * pciBusId, nvmlDevice_t * device); + nvmlReturn_t (*nvmlDeviceGetName)(nvmlDevice_t device, char * name, unsigned int length); + nvmlReturn_t (*nvmlDeviceGetBrand)(nvmlDevice_t device, nvmlBrandType_t * type); + nvmlReturn_t (*nvmlDeviceGetIndex)(nvmlDevice_t device, unsigned int * index); + nvmlReturn_t (*nvmlDeviceGetSerial)(nvmlDevice_t device, char * serial, unsigned int length); + nvmlReturn_t (*nvmlDeviceGetModuleId)(nvmlDevice_t device, unsigned int * moduleId); + nvmlReturn_t (*nvmlDeviceGetC2cModeInfoV)(nvmlDevice_t device, nvmlC2cModeInfo_v1_t * c2cModeInfo); + nvmlReturn_t (*nvmlDeviceGetMemoryAffinity)(nvmlDevice_t device, unsigned int nodeSetSize, unsigned long * nodeSet, nvmlAffinityScope_t scope); + nvmlReturn_t (*nvmlDeviceGetCpuAffinityWithinScope)(nvmlDevice_t device, unsigned int cpuSetSize, unsigned long * cpuSet, nvmlAffinityScope_t scope); + nvmlReturn_t (*nvmlDeviceGetCpuAffinity)(nvmlDevice_t device, unsigned int cpuSetSize, unsigned long * cpuSet); + nvmlReturn_t (*nvmlDeviceSetCpuAffinity)(nvmlDevice_t device); + nvmlReturn_t (*nvmlDeviceClearCpuAffinity)(nvmlDevice_t device); + nvmlReturn_t (*nvmlDeviceGetNumaNodeId)(nvmlDevice_t device, unsigned int * node); + nvmlReturn_t (*nvmlDeviceGetAddressingMode)(nvmlDevice_t device, nvmlDeviceAddressingMode_t * mode); + nvmlReturn_t (*nvmlDeviceGetRepairStatus)(nvmlDevice_t device, nvmlRepairStatus_t * repairStatus); + nvmlReturn_t (*nvmlDeviceGetTopologyCommonAncestor)(nvmlDevice_t device1, nvmlDevice_t device2, nvmlGpuTopologyLevel_t * pathInfo); + nvmlReturn_t (*nvmlDeviceGetTopologyNearestGpus)(nvmlDevice_t device, nvmlGpuTopologyLevel_t level, unsigned int * count, nvmlDevice_t * deviceArray); + nvmlReturn_t (*nvmlDeviceGetP2PStatus)(nvmlDevice_t device1, nvmlDevice_t device2, nvmlGpuP2PCapsIndex_t p2pIndex, nvmlGpuP2PStatus_t * p2pStatus); + nvmlReturn_t (*nvmlDeviceGetUUID)(nvmlDevice_t device, char * uuid, unsigned int length); + nvmlReturn_t (*nvmlDeviceGetMinorNumber)(nvmlDevice_t device, unsigned int * minorNumber); + nvmlReturn_t (*nvmlDeviceGetBoardPartNumber)(nvmlDevice_t device, char* partNumber, unsigned int length); + nvmlReturn_t (*nvmlDeviceGetInforomVersion)(nvmlDevice_t device, nvmlInforomObject_t object, char * version, unsigned int length); + nvmlReturn_t (*nvmlDeviceGetInforomImageVersion)(nvmlDevice_t device, char * version, unsigned int length); + nvmlReturn_t (*nvmlDeviceGetInforomConfigurationChecksum)(nvmlDevice_t device, unsigned int * checksum); + nvmlReturn_t (*nvmlDeviceValidateInforom)(nvmlDevice_t device); + nvmlReturn_t (*nvmlDeviceGetLastBBXFlushTime)(nvmlDevice_t device, unsigned long long * timestamp, unsigned long * durationUs); + nvmlReturn_t (*nvmlDeviceGetDisplayMode)(nvmlDevice_t device, nvmlEnableState_t * display); + nvmlReturn_t (*nvmlDeviceGetDisplayActive)(nvmlDevice_t device, nvmlEnableState_t * isActive); + nvmlReturn_t (*nvmlDeviceGetPersistenceMode)(nvmlDevice_t device, nvmlEnableState_t * mode); + nvmlReturn_t (*nvmlDeviceGetPciInfoExt)(nvmlDevice_t device, nvmlPciInfoExt_t * pci); + nvmlReturn_t (*nvmlDeviceGetPciInfo_v3)(nvmlDevice_t device, nvmlPciInfo_t * pci); + nvmlReturn_t (*nvmlDeviceGetMaxPcieLinkGeneration)(nvmlDevice_t device, unsigned int * maxLinkGen); + nvmlReturn_t (*nvmlDeviceGetGpuMaxPcieLinkGeneration)(nvmlDevice_t device, unsigned int * maxLinkGenDevice); + nvmlReturn_t (*nvmlDeviceGetMaxPcieLinkWidth)(nvmlDevice_t device, unsigned int * maxLinkWidth); + nvmlReturn_t (*nvmlDeviceGetCurrPcieLinkGeneration)(nvmlDevice_t device, unsigned int * currLinkGen); + nvmlReturn_t (*nvmlDeviceGetCurrPcieLinkWidth)(nvmlDevice_t device, unsigned int * currLinkWidth); + nvmlReturn_t (*nvmlDeviceGetPcieThroughput)(nvmlDevice_t device, nvmlPcieUtilCounter_t counter, unsigned int * value); + nvmlReturn_t (*nvmlDeviceGetPcieReplayCounter)(nvmlDevice_t device, unsigned int * value); + nvmlReturn_t (*nvmlDeviceGetClockInfo)(nvmlDevice_t device, nvmlClockType_t type, unsigned int * clock); + nvmlReturn_t (*nvmlDeviceGetMaxClockInfo)(nvmlDevice_t device, nvmlClockType_t type, unsigned int * clock); + nvmlReturn_t (*nvmlDeviceGetGpcClkVfOffset)(nvmlDevice_t device, int * offset); + nvmlReturn_t (*nvmlDeviceGetApplicationsClock)(nvmlDevice_t device, nvmlClockType_t clockType, unsigned int * clockMHz); + nvmlReturn_t (*nvmlDeviceGetDefaultApplicationsClock)(nvmlDevice_t device, nvmlClockType_t clockType, unsigned int * clockMHz); + nvmlReturn_t (*nvmlDeviceGetClock)(nvmlDevice_t device, nvmlClockType_t clockType, nvmlClockId_t clockId, unsigned int * clockMHz); + nvmlReturn_t (*nvmlDeviceGetMaxCustomerBoostClock)(nvmlDevice_t device, nvmlClockType_t clockType, unsigned int * clockMHz); + nvmlReturn_t (*nvmlDeviceGetSupportedMemoryClocks)(nvmlDevice_t device, unsigned int * count, unsigned int * clocksMHz); + nvmlReturn_t (*nvmlDeviceGetSupportedGraphicsClocks)(nvmlDevice_t device, unsigned int memoryClockMHz, unsigned int * count, unsigned int * clocksMHz); + nvmlReturn_t (*nvmlDeviceGetAutoBoostedClocksEnabled)(nvmlDevice_t device, nvmlEnableState_t * isEnabled, nvmlEnableState_t * defaultIsEnabled); + nvmlReturn_t (*nvmlDeviceGetFanSpeed)(nvmlDevice_t device, unsigned int * speed); + nvmlReturn_t (*nvmlDeviceGetFanSpeed_v2)(nvmlDevice_t device, unsigned int fan, unsigned int * speed); + nvmlReturn_t (*nvmlDeviceGetFanSpeedRPM)(nvmlDevice_t device, nvmlFanSpeedInfo_t * fanSpeed); + nvmlReturn_t (*nvmlDeviceGetTargetFanSpeed)(nvmlDevice_t device, unsigned int fan, unsigned int * targetSpeed); + nvmlReturn_t (*nvmlDeviceGetMinMaxFanSpeed)(nvmlDevice_t device, unsigned int * minSpeed, unsigned int * maxSpeed); + nvmlReturn_t (*nvmlDeviceGetFanControlPolicy_v2)(nvmlDevice_t device, unsigned int fan, nvmlFanControlPolicy_t * policy); + nvmlReturn_t (*nvmlDeviceGetNumFans)(nvmlDevice_t device, unsigned int * numFans); + nvmlReturn_t (*nvmlDeviceGetTemperature)(nvmlDevice_t device, nvmlTemperatureSensors_t sensorType, unsigned int * temp); + nvmlReturn_t (*nvmlDeviceGetCoolerInfo)(nvmlDevice_t device, nvmlCoolerInfo_t * coolerInfo); + nvmlReturn_t (*nvmlDeviceGetTemperatureV)(nvmlDevice_t device, nvmlTemperature_t * temperature); + nvmlReturn_t (*nvmlDeviceGetTemperatureThreshold)(nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, unsigned int * temp); + nvmlReturn_t (*nvmlDeviceGetMarginTemperature)(nvmlDevice_t device, nvmlMarginTemperature_t * marginTempInfo); + nvmlReturn_t (*nvmlDeviceGetThermalSettings)(nvmlDevice_t device, unsigned int sensorIndex, nvmlGpuThermalSettings_t * pThermalSettings); + nvmlReturn_t (*nvmlDeviceGetPerformanceState)(nvmlDevice_t device, nvmlPstates_t * pState); + nvmlReturn_t (*nvmlDeviceGetCurrentClocksEventReasons)(nvmlDevice_t device, unsigned long long * clocksEventReasons); + nvmlReturn_t (*nvmlDeviceGetCurrentClocksThrottleReasons)(nvmlDevice_t device, unsigned long long * clocksThrottleReasons); + nvmlReturn_t (*nvmlDeviceGetSupportedClocksEventReasons)(nvmlDevice_t device, unsigned long long * supportedClocksEventReasons); + nvmlReturn_t (*nvmlDeviceGetSupportedClocksThrottleReasons)(nvmlDevice_t device, unsigned long long * supportedClocksThrottleReasons); + nvmlReturn_t (*nvmlDeviceGetPowerState)(nvmlDevice_t device, nvmlPstates_t * pState); + nvmlReturn_t (*nvmlDeviceGetDynamicPstatesInfo)(nvmlDevice_t device, nvmlGpuDynamicPstatesInfo_t * pDynamicPstatesInfo); + nvmlReturn_t (*nvmlDeviceGetMemClkVfOffset)(nvmlDevice_t device, int * offset); + nvmlReturn_t (*nvmlDeviceGetMinMaxClockOfPState)(nvmlDevice_t device, nvmlClockType_t type, nvmlPstates_t pstate, unsigned int * minClockMHz, unsigned int * maxClockMHz); + nvmlReturn_t (*nvmlDeviceGetSupportedPerformanceStates)(nvmlDevice_t device, nvmlPstates_t * pstates, unsigned int size); + nvmlReturn_t (*nvmlDeviceGetGpcClkMinMaxVfOffset)(nvmlDevice_t device, int * minOffset, int * maxOffset); + nvmlReturn_t (*nvmlDeviceGetMemClkMinMaxVfOffset)(nvmlDevice_t device, int * minOffset, int * maxOffset); + nvmlReturn_t (*nvmlDeviceGetClockOffsets)(nvmlDevice_t device, nvmlClockOffset_t * info); + nvmlReturn_t (*nvmlDeviceSetClockOffsets)(nvmlDevice_t device, nvmlClockOffset_t * info); + nvmlReturn_t (*nvmlDeviceGetPerformanceModes)(nvmlDevice_t device, nvmlDevicePerfModes_t * perfModes); + nvmlReturn_t (*nvmlDeviceGetCurrentClockFreqs)(nvmlDevice_t device, nvmlDeviceCurrentClockFreqs_t * currentClockFreqs); + nvmlReturn_t (*nvmlDeviceGetPowerManagementMode)(nvmlDevice_t device, nvmlEnableState_t * mode); + nvmlReturn_t (*nvmlDeviceGetPowerManagementLimit)(nvmlDevice_t device, unsigned int * limit); + nvmlReturn_t (*nvmlDeviceGetPowerManagementLimitConstraints)(nvmlDevice_t device, unsigned int * minLimit, unsigned int * maxLimit); + nvmlReturn_t (*nvmlDeviceGetPowerManagementDefaultLimit)(nvmlDevice_t device, unsigned int * defaultLimit); + nvmlReturn_t (*nvmlDeviceGetPowerUsage)(nvmlDevice_t device, unsigned int * power); + nvmlReturn_t (*nvmlDeviceGetPowerMizerMode_v1)(nvmlDevice_t device, nvmlDevicePowerMizerModes_v1_t * powerMizerMode); + nvmlReturn_t (*nvmlDeviceSetPowerMizerMode_v1)(nvmlDevice_t device, nvmlDevicePowerMizerModes_v1_t * powerMizerMode); + nvmlReturn_t (*nvmlDeviceGetTotalEnergyConsumption)(nvmlDevice_t device, unsigned long long * energy); + nvmlReturn_t (*nvmlDeviceGetEnforcedPowerLimit)(nvmlDevice_t device, unsigned int * limit); + nvmlReturn_t (*nvmlDeviceGetGpuOperationMode)(nvmlDevice_t device, nvmlGpuOperationMode_t * current, nvmlGpuOperationMode_t * pending); + nvmlReturn_t (*nvmlDeviceGetMemoryInfo)(nvmlDevice_t device, nvmlMemory_t * memory); + nvmlReturn_t (*nvmlDeviceGetMemoryInfo_v2)(nvmlDevice_t device, nvmlMemory_v2_t * memory); + nvmlReturn_t (*nvmlDeviceGetComputeMode)(nvmlDevice_t device, nvmlComputeMode_t * mode); + nvmlReturn_t (*nvmlDeviceGetCudaComputeCapability)(nvmlDevice_t device, int * major, int * minor); + nvmlReturn_t (*nvmlDeviceGetDramEncryptionMode)(nvmlDevice_t device, nvmlDramEncryptionInfo_t * current, nvmlDramEncryptionInfo_t * pending); + nvmlReturn_t (*nvmlDeviceSetDramEncryptionMode)(nvmlDevice_t device, const nvmlDramEncryptionInfo_t * dramEncryption); + nvmlReturn_t (*nvmlDeviceGetEccMode)(nvmlDevice_t device, nvmlEnableState_t * current, nvmlEnableState_t * pending); + nvmlReturn_t (*nvmlDeviceGetDefaultEccMode)(nvmlDevice_t device, nvmlEnableState_t * defaultMode); + nvmlReturn_t (*nvmlDeviceGetBoardId)(nvmlDevice_t device, unsigned int * boardId); + nvmlReturn_t (*nvmlDeviceGetMultiGpuBoard)(nvmlDevice_t device, unsigned int * multiGpuBool); + nvmlReturn_t (*nvmlDeviceGetTotalEccErrors)(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, unsigned long long * eccCounts); + nvmlReturn_t (*nvmlDeviceGetDetailedEccErrors)(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, nvmlEccErrorCounts_t * eccCounts); + nvmlReturn_t (*nvmlDeviceGetMemoryErrorCounter)(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, nvmlMemoryLocation_t locationType, unsigned long long * count); + nvmlReturn_t (*nvmlDeviceGetUtilizationRates)(nvmlDevice_t device, nvmlUtilization_t * utilization); + nvmlReturn_t (*nvmlDeviceGetEncoderUtilization)(nvmlDevice_t device, unsigned int * utilization, unsigned int * samplingPeriodUs); + nvmlReturn_t (*nvmlDeviceGetEncoderCapacity)(nvmlDevice_t device, nvmlEncoderType_t encoderQueryType, unsigned int * encoderCapacity); + nvmlReturn_t (*nvmlDeviceGetEncoderStats)(nvmlDevice_t device, unsigned int * sessionCount, unsigned int * averageFps, unsigned int * averageLatency); + nvmlReturn_t (*nvmlDeviceGetEncoderSessions)(nvmlDevice_t device, unsigned int * sessionCount, nvmlEncoderSessionInfo_t * sessionInfos); + nvmlReturn_t (*nvmlDeviceGetDecoderUtilization)(nvmlDevice_t device, unsigned int * utilization, unsigned int * samplingPeriodUs); + nvmlReturn_t (*nvmlDeviceGetJpgUtilization)(nvmlDevice_t device, unsigned int * utilization, unsigned int * samplingPeriodUs); + nvmlReturn_t (*nvmlDeviceGetOfaUtilization)(nvmlDevice_t device, unsigned int * utilization, unsigned int * samplingPeriodUs); + nvmlReturn_t (*nvmlDeviceGetFBCStats)(nvmlDevice_t device, nvmlFBCStats_t * fbcStats); + nvmlReturn_t (*nvmlDeviceGetFBCSessions)(nvmlDevice_t device, unsigned int * sessionCount, nvmlFBCSessionInfo_t * sessionInfo); + nvmlReturn_t (*nvmlDeviceGetDriverModel_v2)(nvmlDevice_t device, nvmlDriverModel_t * current, nvmlDriverModel_t * pending); + nvmlReturn_t (*nvmlDeviceGetVbiosVersion)(nvmlDevice_t device, char * version, unsigned int length); + nvmlReturn_t (*nvmlDeviceGetBridgeChipInfo)(nvmlDevice_t device, nvmlBridgeChipHierarchy_t * bridgeHierarchy); + nvmlReturn_t (*nvmlDeviceGetComputeRunningProcesses_v3)(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_t * infos); + nvmlReturn_t (*nvmlDeviceGetGraphicsRunningProcesses_v3)(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_t * infos); + nvmlReturn_t (*nvmlDeviceGetMPSComputeRunningProcesses_v3)(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_t * infos); + nvmlReturn_t (*nvmlDeviceGetRunningProcessDetailList)(nvmlDevice_t device, nvmlProcessDetailList_t * plist); + nvmlReturn_t (*nvmlDeviceOnSameBoard)(nvmlDevice_t device1, nvmlDevice_t device2, int * onSameBoard); + nvmlReturn_t (*nvmlDeviceGetAPIRestriction)(nvmlDevice_t device, nvmlRestrictedAPI_t apiType, nvmlEnableState_t * isRestricted); + nvmlReturn_t (*nvmlDeviceGetSamples)(nvmlDevice_t device, nvmlSamplingType_t type, unsigned long long lastSeenTimeStamp, nvmlValueType_t * sampleValType, unsigned int * sampleCount, nvmlSample_t * samples); + nvmlReturn_t (*nvmlDeviceGetBAR1MemoryInfo)(nvmlDevice_t device, nvmlBAR1Memory_t * bar1Memory); + nvmlReturn_t (*nvmlDeviceGetViolationStatus)(nvmlDevice_t device, nvmlPerfPolicyType_t perfPolicyType, nvmlViolationTime_t * violTime); + nvmlReturn_t (*nvmlDeviceGetIrqNum)(nvmlDevice_t device, unsigned int * irqNum); + nvmlReturn_t (*nvmlDeviceGetNumGpuCores)(nvmlDevice_t device, unsigned int * numCores); + nvmlReturn_t (*nvmlDeviceGetPowerSource)(nvmlDevice_t device, nvmlPowerSource_t * powerSource); + nvmlReturn_t (*nvmlDeviceGetMemoryBusWidth)(nvmlDevice_t device, unsigned int * busWidth); + nvmlReturn_t (*nvmlDeviceGetPcieLinkMaxSpeed)(nvmlDevice_t device, unsigned int * maxSpeed); + nvmlReturn_t (*nvmlDeviceGetPcieSpeed)(nvmlDevice_t device, unsigned int * pcieSpeed); + nvmlReturn_t (*nvmlDeviceGetAdaptiveClockInfoStatus)(nvmlDevice_t device, unsigned int * adaptiveClockStatus); + nvmlReturn_t (*nvmlDeviceGetBusType)(nvmlDevice_t device, nvmlBusType_t * type); + nvmlReturn_t (*nvmlDeviceGetGpuFabricInfo)(nvmlDevice_t device, nvmlGpuFabricInfo_t * gpuFabricInfo); + nvmlReturn_t (*nvmlDeviceGetGpuFabricInfoV)(nvmlDevice_t device, nvmlGpuFabricInfoV_t * gpuFabricInfo); + nvmlReturn_t (*nvmlSystemGetConfComputeCapabilities)(nvmlConfComputeSystemCaps_t * capabilities); + nvmlReturn_t (*nvmlSystemGetConfComputeState)(nvmlConfComputeSystemState_t * state); + nvmlReturn_t (*nvmlDeviceGetConfComputeMemSizeInfo)(nvmlDevice_t device, nvmlConfComputeMemSizeInfo_t * memInfo); + nvmlReturn_t (*nvmlSystemGetConfComputeGpusReadyState)(unsigned int * isAcceptingWork); + nvmlReturn_t (*nvmlDeviceGetConfComputeProtectedMemoryUsage)(nvmlDevice_t device, nvmlMemory_t * memory); + nvmlReturn_t (*nvmlDeviceGetConfComputeGpuCertificate)(nvmlDevice_t device, nvmlConfComputeGpuCertificate_t * gpuCert); + nvmlReturn_t (*nvmlDeviceGetConfComputeGpuAttestationReport)(nvmlDevice_t device, nvmlConfComputeGpuAttestationReport_t * gpuAtstReport); + nvmlReturn_t (*nvmlSystemGetConfComputeKeyRotationThresholdInfo)(nvmlConfComputeGetKeyRotationThresholdInfo_t * pKeyRotationThrInfo); + nvmlReturn_t (*nvmlDeviceSetConfComputeUnprotectedMemSize)(nvmlDevice_t device, unsigned long long sizeKiB); + nvmlReturn_t (*nvmlSystemSetConfComputeGpusReadyState)(unsigned int isAcceptingWork); + nvmlReturn_t (*nvmlSystemSetConfComputeKeyRotationThresholdInfo)(nvmlConfComputeSetKeyRotationThresholdInfo_t * pKeyRotationThrInfo); + nvmlReturn_t (*nvmlSystemGetConfComputeSettings)(nvmlSystemConfComputeSettings_t * settings); + nvmlReturn_t (*nvmlDeviceGetGspFirmwareVersion)(nvmlDevice_t device, char * version); + nvmlReturn_t (*nvmlDeviceGetGspFirmwareMode)(nvmlDevice_t device, unsigned int * isEnabled, unsigned int * defaultMode); + nvmlReturn_t (*nvmlDeviceGetSramEccErrorStatus)(nvmlDevice_t device, nvmlEccSramErrorStatus_t * status); + nvmlReturn_t (*nvmlDeviceSetPowerManagementLimit_v2)(nvmlDevice_t device, nvmlPowerValue_v2_t * powerValue); + nvmlReturn_t (*nvmlDeviceGetAccountingMode)(nvmlDevice_t device, nvmlEnableState_t * mode); + nvmlReturn_t (*nvmlDeviceGetAccountingStats)(nvmlDevice_t device, unsigned int pid, nvmlAccountingStats_t * stats); + nvmlReturn_t (*nvmlDeviceGetAccountingPids)(nvmlDevice_t device, unsigned int * count, unsigned int * pids); + nvmlReturn_t (*nvmlDeviceGetAccountingBufferSize)(nvmlDevice_t device, unsigned int * bufferSize); + nvmlReturn_t (*nvmlDeviceGetRetiredPages)(nvmlDevice_t device, nvmlPageRetirementCause_t cause, unsigned int * pageCount, unsigned long long * addresses); + nvmlReturn_t (*nvmlDeviceGetRetiredPages_v2)(nvmlDevice_t device, nvmlPageRetirementCause_t cause, unsigned int * pageCount, unsigned long long * addresses, unsigned long long * timestamps); + nvmlReturn_t (*nvmlDeviceGetRetiredPagesPendingStatus)(nvmlDevice_t device, nvmlEnableState_t * isPending); + nvmlReturn_t (*nvmlDeviceGetRemappedRows)(nvmlDevice_t device, unsigned int * corrRows, unsigned int * uncRows, unsigned int * isPending, unsigned int * failureOccurred); + nvmlReturn_t (*nvmlDeviceGetRowRemapperHistogram)(nvmlDevice_t device, nvmlRowRemapperHistogramValues_t * values); + nvmlReturn_t (*nvmlDeviceGetArchitecture)(nvmlDevice_t device, nvmlDeviceArchitecture_t * arch); + nvmlReturn_t (*nvmlDeviceGetClkMonStatus)(nvmlDevice_t device, nvmlClkMonStatus_t * status); + nvmlReturn_t (*nvmlDeviceGetProcessUtilization)(nvmlDevice_t device, nvmlProcessUtilizationSample_t * utilization, unsigned int * processSamplesCount, unsigned long long lastSeenTimeStamp); + nvmlReturn_t (*nvmlDeviceGetProcessesUtilizationInfo)(nvmlDevice_t device, nvmlProcessesUtilizationInfo_t * procesesUtilInfo); + nvmlReturn_t (*nvmlDeviceGetPlatformInfo)(nvmlDevice_t device, nvmlPlatformInfo_t * platformInfo); + nvmlReturn_t (*nvmlDeviceGetPdi)(nvmlDevice_t device, nvmlPdi_t * pdi); + nvmlReturn_t (*nvmlUnitSetLedState)(nvmlUnit_t unit, nvmlLedColor_t color); + nvmlReturn_t (*nvmlDeviceSetPersistenceMode)(nvmlDevice_t device, nvmlEnableState_t mode); + nvmlReturn_t (*nvmlDeviceSetComputeMode)(nvmlDevice_t device, nvmlComputeMode_t mode); + nvmlReturn_t (*nvmlDeviceSetEccMode)(nvmlDevice_t device, nvmlEnableState_t ecc); + nvmlReturn_t (*nvmlDeviceClearEccErrorCounts)(nvmlDevice_t device, nvmlEccCounterType_t counterType); + nvmlReturn_t (*nvmlDeviceSetDriverModel)(nvmlDevice_t device, nvmlDriverModel_t driverModel, unsigned int flags); + nvmlReturn_t (*nvmlDeviceSetGpuLockedClocks)(nvmlDevice_t device, unsigned int minGpuClockMHz, unsigned int maxGpuClockMHz); + nvmlReturn_t (*nvmlDeviceResetGpuLockedClocks)(nvmlDevice_t device); + nvmlReturn_t (*nvmlDeviceSetMemoryLockedClocks)(nvmlDevice_t device, unsigned int minMemClockMHz, unsigned int maxMemClockMHz); + nvmlReturn_t (*nvmlDeviceResetMemoryLockedClocks)(nvmlDevice_t device); + nvmlReturn_t (*nvmlDeviceSetApplicationsClocks)(nvmlDevice_t device, unsigned int memClockMHz, unsigned int graphicsClockMHz); + nvmlReturn_t (*nvmlDeviceResetApplicationsClocks)(nvmlDevice_t device); + nvmlReturn_t (*nvmlDeviceSetAutoBoostedClocksEnabled)(nvmlDevice_t device, nvmlEnableState_t enabled); + nvmlReturn_t (*nvmlDeviceSetDefaultAutoBoostedClocksEnabled)(nvmlDevice_t device, nvmlEnableState_t enabled, unsigned int flags); + nvmlReturn_t (*nvmlDeviceSetDefaultFanSpeed_v2)(nvmlDevice_t device, unsigned int fan); + nvmlReturn_t (*nvmlDeviceSetFanControlPolicy)(nvmlDevice_t device, unsigned int fan, nvmlFanControlPolicy_t policy); + nvmlReturn_t (*nvmlDeviceSetTemperatureThreshold)(nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, int * temp); + nvmlReturn_t (*nvmlDeviceSetPowerManagementLimit)(nvmlDevice_t device, unsigned int limit); + nvmlReturn_t (*nvmlDeviceSetGpuOperationMode)(nvmlDevice_t device, nvmlGpuOperationMode_t mode); + nvmlReturn_t (*nvmlDeviceSetAPIRestriction)(nvmlDevice_t device, nvmlRestrictedAPI_t apiType, nvmlEnableState_t isRestricted); + nvmlReturn_t (*nvmlDeviceSetFanSpeed_v2)(nvmlDevice_t device, unsigned int fan, unsigned int speed); + nvmlReturn_t (*nvmlDeviceSetGpcClkVfOffset)(nvmlDevice_t device, int offset); + nvmlReturn_t (*nvmlDeviceSetMemClkVfOffset)(nvmlDevice_t device, int offset); + nvmlReturn_t (*nvmlDeviceSetAccountingMode)(nvmlDevice_t device, nvmlEnableState_t mode); + nvmlReturn_t (*nvmlDeviceClearAccountingPids)(nvmlDevice_t device); + nvmlReturn_t (*nvmlDeviceGetNvLinkState)(nvmlDevice_t device, unsigned int link, nvmlEnableState_t * isActive); + nvmlReturn_t (*nvmlDeviceGetNvLinkVersion)(nvmlDevice_t device, unsigned int link, unsigned int * version); + nvmlReturn_t (*nvmlDeviceGetNvLinkCapability)(nvmlDevice_t device, unsigned int link, nvmlNvLinkCapability_t capability, unsigned int * capResult); + nvmlReturn_t (*nvmlDeviceGetNvLinkRemotePciInfo_v2)(nvmlDevice_t device, unsigned int link, nvmlPciInfo_t * pci); + nvmlReturn_t (*nvmlDeviceGetNvLinkErrorCounter)(nvmlDevice_t device, unsigned int link, nvmlNvLinkErrorCounter_t counter, unsigned long long * counterValue); + nvmlReturn_t (*nvmlDeviceResetNvLinkErrorCounters)(nvmlDevice_t device, unsigned int link); + nvmlReturn_t (*nvmlDeviceSetNvLinkUtilizationControl)(nvmlDevice_t device, unsigned int link, unsigned int counter, nvmlNvLinkUtilizationControl_t * control, unsigned int reset); + nvmlReturn_t (*nvmlDeviceGetNvLinkUtilizationControl)(nvmlDevice_t device, unsigned int link, unsigned int counter, nvmlNvLinkUtilizationControl_t * control); + nvmlReturn_t (*nvmlDeviceGetNvLinkUtilizationCounter)(nvmlDevice_t device, unsigned int link, unsigned int counter, unsigned long long * rxcounter, unsigned long long * txcounter); + nvmlReturn_t (*nvmlDeviceFreezeNvLinkUtilizationCounter)(nvmlDevice_t device, unsigned int link, unsigned int counter, nvmlEnableState_t freeze); + nvmlReturn_t (*nvmlDeviceResetNvLinkUtilizationCounter)(nvmlDevice_t device, unsigned int link, unsigned int counter); + nvmlReturn_t (*nvmlDeviceGetNvLinkRemoteDeviceType)(nvmlDevice_t device, unsigned int link, nvmlIntNvLinkDeviceType_t * pNvLinkDeviceType); + nvmlReturn_t (*nvmlDeviceSetNvLinkDeviceLowPowerThreshold)(nvmlDevice_t device, nvmlNvLinkPowerThres_t * info); + nvmlReturn_t (*nvmlSystemSetNvlinkBwMode)(unsigned int nvlinkBwMode); + nvmlReturn_t (*nvmlSystemGetNvlinkBwMode)(unsigned int * nvlinkBwMode); + nvmlReturn_t (*nvmlDeviceGetNvlinkSupportedBwModes)(nvmlDevice_t device, nvmlNvlinkSupportedBwModes_t * supportedBwMode); + nvmlReturn_t (*nvmlDeviceGetNvlinkBwMode)(nvmlDevice_t device, nvmlNvlinkGetBwMode_t * getBwMode); + nvmlReturn_t (*nvmlDeviceSetNvlinkBwMode)(nvmlDevice_t device, nvmlNvlinkSetBwMode_t * setBwMode); + nvmlReturn_t (*nvmlDeviceGetNvLinkInfo)(nvmlDevice_t device, nvmlNvLinkInfo_t * info); + nvmlReturn_t (*nvmlEventSetCreate)(nvmlEventSet_t * set); + nvmlReturn_t (*nvmlDeviceRegisterEvents)(nvmlDevice_t device, unsigned long long eventTypes, nvmlEventSet_t set); + nvmlReturn_t (*nvmlDeviceGetSupportedEventTypes)(nvmlDevice_t device, unsigned long long * eventTypes); + nvmlReturn_t (*nvmlEventSetWait_v2)(nvmlEventSet_t set, nvmlEventData_t * data, unsigned int timeoutms); + nvmlReturn_t (*nvmlEventSetFree)(nvmlEventSet_t set); + nvmlReturn_t (*nvmlSystemEventSetCreate)(nvmlSystemEventSetCreateRequest_t * request); + nvmlReturn_t (*nvmlSystemEventSetFree)(nvmlSystemEventSetFreeRequest_t * request); + nvmlReturn_t (*nvmlSystemRegisterEvents)(nvmlSystemRegisterEventRequest_t * request); + nvmlReturn_t (*nvmlSystemEventSetWait)(nvmlSystemEventSetWaitRequest_t * request); + nvmlReturn_t (*nvmlDeviceModifyDrainState)(nvmlPciInfo_t * pciInfo, nvmlEnableState_t newState); + nvmlReturn_t (*nvmlDeviceQueryDrainState)(nvmlPciInfo_t * pciInfo, nvmlEnableState_t * currentState); + nvmlReturn_t (*nvmlDeviceRemoveGpu_v2)(nvmlPciInfo_t * pciInfo, nvmlDetachGpuState_t gpuState, nvmlPcieLinkState_t linkState); + nvmlReturn_t (*nvmlDeviceDiscoverGpus)(nvmlPciInfo_t * pciInfo); + nvmlReturn_t (*nvmlDeviceGetFieldValues)(nvmlDevice_t device, int valuesCount, nvmlFieldValue_t * values); + nvmlReturn_t (*nvmlDeviceClearFieldValues)(nvmlDevice_t device, int valuesCount, nvmlFieldValue_t * values); + nvmlReturn_t (*nvmlDeviceGetVirtualizationMode)(nvmlDevice_t device, nvmlGpuVirtualizationMode_t * pVirtualMode); + nvmlReturn_t (*nvmlDeviceGetHostVgpuMode)(nvmlDevice_t device, nvmlHostVgpuMode_t * pHostVgpuMode); + nvmlReturn_t (*nvmlDeviceSetVirtualizationMode)(nvmlDevice_t device, nvmlGpuVirtualizationMode_t virtualMode); + nvmlReturn_t (*nvmlDeviceGetVgpuHeterogeneousMode)(nvmlDevice_t device, nvmlVgpuHeterogeneousMode_t * pHeterogeneousMode); + nvmlReturn_t (*nvmlDeviceSetVgpuHeterogeneousMode)(nvmlDevice_t device, const nvmlVgpuHeterogeneousMode_t * pHeterogeneousMode); + nvmlReturn_t (*nvmlVgpuInstanceGetPlacementId)(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuPlacementId_t * pPlacement); + nvmlReturn_t (*nvmlDeviceGetVgpuTypeSupportedPlacements)(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuPlacementList_t * pPlacementList); + nvmlReturn_t (*nvmlDeviceGetVgpuTypeCreatablePlacements)(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuPlacementList_t * pPlacementList); + nvmlReturn_t (*nvmlVgpuTypeGetGspHeapSize)(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long * gspHeapSize); + nvmlReturn_t (*nvmlVgpuTypeGetFbReservation)(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long * fbReservation); + nvmlReturn_t (*nvmlVgpuInstanceGetRuntimeStateSize)(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuRuntimeState_t * pState); + nvmlReturn_t (*nvmlDeviceSetVgpuCapabilities)(nvmlDevice_t device, nvmlDeviceVgpuCapability_t capability, nvmlEnableState_t state); + nvmlReturn_t (*nvmlDeviceGetGridLicensableFeatures_v4)(nvmlDevice_t device, nvmlGridLicensableFeatures_t * pGridLicensableFeatures); + nvmlReturn_t (*nvmlGetVgpuDriverCapabilities)(nvmlVgpuDriverCapability_t capability, unsigned int * capResult); + nvmlReturn_t (*nvmlDeviceGetVgpuCapabilities)(nvmlDevice_t device, nvmlDeviceVgpuCapability_t capability, unsigned int * capResult); + nvmlReturn_t (*nvmlDeviceGetSupportedVgpus)(nvmlDevice_t device, unsigned int * vgpuCount, nvmlVgpuTypeId_t * vgpuTypeIds); + nvmlReturn_t (*nvmlDeviceGetCreatableVgpus)(nvmlDevice_t device, unsigned int * vgpuCount, nvmlVgpuTypeId_t * vgpuTypeIds); + nvmlReturn_t (*nvmlVgpuTypeGetClass)(nvmlVgpuTypeId_t vgpuTypeId, char * vgpuTypeClass, unsigned int * size); + nvmlReturn_t (*nvmlVgpuTypeGetName)(nvmlVgpuTypeId_t vgpuTypeId, char * vgpuTypeName, unsigned int * size); + nvmlReturn_t (*nvmlVgpuTypeGetGpuInstanceProfileId)(nvmlVgpuTypeId_t vgpuTypeId, unsigned int * gpuInstanceProfileId); + nvmlReturn_t (*nvmlVgpuTypeGetDeviceID)(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long * deviceID, unsigned long long * subsystemID); + nvmlReturn_t (*nvmlVgpuTypeGetFramebufferSize)(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long * fbSize); + nvmlReturn_t (*nvmlVgpuTypeGetNumDisplayHeads)(nvmlVgpuTypeId_t vgpuTypeId, unsigned int * numDisplayHeads); + nvmlReturn_t (*nvmlVgpuTypeGetResolution)(nvmlVgpuTypeId_t vgpuTypeId, unsigned int displayIndex, unsigned int * xdim, unsigned int * ydim); + nvmlReturn_t (*nvmlVgpuTypeGetLicense)(nvmlVgpuTypeId_t vgpuTypeId, char * vgpuTypeLicenseString, unsigned int size); + nvmlReturn_t (*nvmlVgpuTypeGetFrameRateLimit)(nvmlVgpuTypeId_t vgpuTypeId, unsigned int * frameRateLimit); + nvmlReturn_t (*nvmlVgpuTypeGetMaxInstances)(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, unsigned int * vgpuInstanceCount); + nvmlReturn_t (*nvmlVgpuTypeGetMaxInstancesPerVm)(nvmlVgpuTypeId_t vgpuTypeId, unsigned int * vgpuInstanceCountPerVm); + nvmlReturn_t (*nvmlVgpuTypeGetBAR1Info)(nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuTypeBar1Info_t * bar1Info); + nvmlReturn_t (*nvmlDeviceGetActiveVgpus)(nvmlDevice_t device, unsigned int * vgpuCount, nvmlVgpuInstance_t * vgpuInstances); + nvmlReturn_t (*nvmlVgpuInstanceGetVmID)(nvmlVgpuInstance_t vgpuInstance, char * vmId, unsigned int size, nvmlVgpuVmIdType_t * vmIdType); + nvmlReturn_t (*nvmlVgpuInstanceGetUUID)(nvmlVgpuInstance_t vgpuInstance, char * uuid, unsigned int size); + nvmlReturn_t (*nvmlVgpuInstanceGetVmDriverVersion)(nvmlVgpuInstance_t vgpuInstance, char* version, unsigned int length); + nvmlReturn_t (*nvmlVgpuInstanceGetFbUsage)(nvmlVgpuInstance_t vgpuInstance, unsigned long long * fbUsage); + nvmlReturn_t (*nvmlVgpuInstanceGetLicenseStatus)(nvmlVgpuInstance_t vgpuInstance, unsigned int * licensed); + nvmlReturn_t (*nvmlVgpuInstanceGetType)(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuTypeId_t * vgpuTypeId); + nvmlReturn_t (*nvmlVgpuInstanceGetFrameRateLimit)(nvmlVgpuInstance_t vgpuInstance, unsigned int * frameRateLimit); + nvmlReturn_t (*nvmlVgpuInstanceGetEccMode)(nvmlVgpuInstance_t vgpuInstance, nvmlEnableState_t * eccMode); + nvmlReturn_t (*nvmlVgpuInstanceGetEncoderCapacity)(nvmlVgpuInstance_t vgpuInstance, unsigned int * encoderCapacity); + nvmlReturn_t (*nvmlVgpuInstanceSetEncoderCapacity)(nvmlVgpuInstance_t vgpuInstance, unsigned int encoderCapacity); + nvmlReturn_t (*nvmlVgpuInstanceGetEncoderStats)(nvmlVgpuInstance_t vgpuInstance, unsigned int * sessionCount, unsigned int * averageFps, unsigned int * averageLatency); + nvmlReturn_t (*nvmlVgpuInstanceGetEncoderSessions)(nvmlVgpuInstance_t vgpuInstance, unsigned int * sessionCount, nvmlEncoderSessionInfo_t * sessionInfo); + nvmlReturn_t (*nvmlVgpuInstanceGetFBCStats)(nvmlVgpuInstance_t vgpuInstance, nvmlFBCStats_t * fbcStats); + nvmlReturn_t (*nvmlVgpuInstanceGetFBCSessions)(nvmlVgpuInstance_t vgpuInstance, unsigned int * sessionCount, nvmlFBCSessionInfo_t * sessionInfo); + nvmlReturn_t (*nvmlVgpuInstanceGetGpuInstanceId)(nvmlVgpuInstance_t vgpuInstance, unsigned int * gpuInstanceId); + nvmlReturn_t (*nvmlVgpuInstanceGetGpuPciId)(nvmlVgpuInstance_t vgpuInstance, char * vgpuPciId, unsigned int * length); + nvmlReturn_t (*nvmlVgpuTypeGetCapabilities)(nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuCapability_t capability, unsigned int * capResult); + nvmlReturn_t (*nvmlVgpuInstanceGetMdevUUID)(nvmlVgpuInstance_t vgpuInstance, char * mdevUuid, unsigned int size); + nvmlReturn_t (*nvmlGpuInstanceGetCreatableVgpus)(nvmlGpuInstance_t gpuInstance, nvmlVgpuTypeIdInfo_t * pVgpus); + nvmlReturn_t (*nvmlVgpuTypeGetMaxInstancesPerGpuInstance)(nvmlVgpuTypeMaxInstance_t * pMaxInstance); + nvmlReturn_t (*nvmlGpuInstanceGetActiveVgpus)(nvmlGpuInstance_t gpuInstance, nvmlActiveVgpuInstanceInfo_t * pVgpuInstanceInfo); + nvmlReturn_t (*nvmlGpuInstanceSetVgpuSchedulerState)(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerState_t * pScheduler); + nvmlReturn_t (*nvmlGpuInstanceGetVgpuSchedulerState)(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerStateInfo_t * pSchedulerStateInfo); + nvmlReturn_t (*nvmlGpuInstanceGetVgpuSchedulerLog)(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerLogInfo_t * pSchedulerLogInfo); + nvmlReturn_t (*nvmlGpuInstanceGetVgpuTypeCreatablePlacements)(nvmlGpuInstance_t gpuInstance, nvmlVgpuCreatablePlacementInfo_t * pCreatablePlacementInfo); + nvmlReturn_t (*nvmlGpuInstanceGetVgpuHeterogeneousMode)(nvmlGpuInstance_t gpuInstance, nvmlVgpuHeterogeneousMode_t * pHeterogeneousMode); + nvmlReturn_t (*nvmlGpuInstanceSetVgpuHeterogeneousMode)(nvmlGpuInstance_t gpuInstance, const nvmlVgpuHeterogeneousMode_t * pHeterogeneousMode); + nvmlReturn_t (*nvmlVgpuInstanceGetMetadata)(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuMetadata_t * vgpuMetadata, unsigned int * bufferSize); + nvmlReturn_t (*nvmlDeviceGetVgpuMetadata)(nvmlDevice_t device, nvmlVgpuPgpuMetadata_t * pgpuMetadata, unsigned int * bufferSize); + nvmlReturn_t (*nvmlGetVgpuCompatibility)(nvmlVgpuMetadata_t * vgpuMetadata, nvmlVgpuPgpuMetadata_t * pgpuMetadata, nvmlVgpuPgpuCompatibility_t * compatibilityInfo); + nvmlReturn_t (*nvmlDeviceGetPgpuMetadataString)(nvmlDevice_t device, char * pgpuMetadata, unsigned int * bufferSize); + nvmlReturn_t (*nvmlDeviceGetVgpuSchedulerLog)(nvmlDevice_t device, nvmlVgpuSchedulerLog_t * pSchedulerLog); + nvmlReturn_t (*nvmlDeviceGetVgpuSchedulerState)(nvmlDevice_t device, nvmlVgpuSchedulerGetState_t * pSchedulerState); + nvmlReturn_t (*nvmlDeviceGetVgpuSchedulerCapabilities)(nvmlDevice_t device, nvmlVgpuSchedulerCapabilities_t * pCapabilities); + nvmlReturn_t (*nvmlDeviceSetVgpuSchedulerState)(nvmlDevice_t device, nvmlVgpuSchedulerSetState_t * pSchedulerState); + nvmlReturn_t (*nvmlGetVgpuVersion)(nvmlVgpuVersion_t * supported, nvmlVgpuVersion_t * current); + nvmlReturn_t (*nvmlSetVgpuVersion)(nvmlVgpuVersion_t * vgpuVersion); + nvmlReturn_t (*nvmlDeviceGetVgpuUtilization)(nvmlDevice_t device, unsigned long long lastSeenTimeStamp, nvmlValueType_t * sampleValType, unsigned int * vgpuInstanceSamplesCount, nvmlVgpuInstanceUtilizationSample_t * utilizationSamples); + nvmlReturn_t (*nvmlDeviceGetVgpuInstancesUtilizationInfo)(nvmlDevice_t device, nvmlVgpuInstancesUtilizationInfo_t * vgpuUtilInfo); + nvmlReturn_t (*nvmlDeviceGetVgpuProcessUtilization)(nvmlDevice_t device, unsigned long long lastSeenTimeStamp, unsigned int * vgpuProcessSamplesCount, nvmlVgpuProcessUtilizationSample_t * utilizationSamples); + nvmlReturn_t (*nvmlDeviceGetVgpuProcessesUtilizationInfo)(nvmlDevice_t device, nvmlVgpuProcessesUtilizationInfo_t * vgpuProcUtilInfo); + nvmlReturn_t (*nvmlVgpuInstanceGetAccountingMode)(nvmlVgpuInstance_t vgpuInstance, nvmlEnableState_t * mode); + nvmlReturn_t (*nvmlVgpuInstanceGetAccountingPids)(nvmlVgpuInstance_t vgpuInstance, unsigned int * count, unsigned int * pids); + nvmlReturn_t (*nvmlVgpuInstanceGetAccountingStats)(nvmlVgpuInstance_t vgpuInstance, unsigned int pid, nvmlAccountingStats_t * stats); + nvmlReturn_t (*nvmlVgpuInstanceClearAccountingPids)(nvmlVgpuInstance_t vgpuInstance); + nvmlReturn_t (*nvmlVgpuInstanceGetLicenseInfo_v2)(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuLicenseInfo_t * licenseInfo); + nvmlReturn_t (*nvmlGetExcludedDeviceCount)(unsigned int * deviceCount); + nvmlReturn_t (*nvmlGetExcludedDeviceInfoByIndex)(unsigned int index, nvmlExcludedDeviceInfo_t * info); + nvmlReturn_t (*nvmlDeviceReadWritePRM_v1)(nvmlDevice_t device, nvmlPRMTLV_v1_t * buffer); + nvmlReturn_t (*nvmlDeviceSetMigMode)(nvmlDevice_t device, unsigned int mode, nvmlReturn_t * activationStatus); + nvmlReturn_t (*nvmlDeviceGetMigMode)(nvmlDevice_t device, unsigned int * currentMode, unsigned int * pendingMode); + nvmlReturn_t (*nvmlDeviceGetGpuInstanceProfileInfo)(nvmlDevice_t device, unsigned int profile, nvmlGpuInstanceProfileInfo_t * info); + nvmlReturn_t (*nvmlDeviceGetGpuInstanceProfileInfoV)(nvmlDevice_t device, unsigned int profile, nvmlGpuInstanceProfileInfo_v2_t * info); + nvmlReturn_t (*nvmlDeviceGetGpuInstanceProfileInfoByIdV)(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstanceProfileInfo_v2_t * info); + nvmlReturn_t (*nvmlDeviceGetGpuInstancePossiblePlacements_v2)(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstancePlacement_t * placements, unsigned int * count); + nvmlReturn_t (*nvmlDeviceGetGpuInstanceRemainingCapacity)(nvmlDevice_t device, unsigned int profileId, unsigned int * count); + nvmlReturn_t (*nvmlDeviceCreateGpuInstance)(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstance_t * gpuInstance); + nvmlReturn_t (*nvmlDeviceCreateGpuInstanceWithPlacement)(nvmlDevice_t device, unsigned int profileId, const nvmlGpuInstancePlacement_t * placement, nvmlGpuInstance_t * gpuInstance); + nvmlReturn_t (*nvmlGpuInstanceDestroy)(nvmlGpuInstance_t gpuInstance); + nvmlReturn_t (*nvmlDeviceGetGpuInstances)(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstance_t * gpuInstances, unsigned int * count); + nvmlReturn_t (*nvmlDeviceGetGpuInstanceById)(nvmlDevice_t device, unsigned int id, nvmlGpuInstance_t * gpuInstance); + nvmlReturn_t (*nvmlGpuInstanceGetInfo)(nvmlGpuInstance_t gpuInstance, nvmlGpuInstanceInfo_t * info); + nvmlReturn_t (*nvmlGpuInstanceGetComputeInstanceProfileInfo)(nvmlGpuInstance_t gpuInstance, unsigned int profile, unsigned int engProfile, nvmlComputeInstanceProfileInfo_t * info); + nvmlReturn_t (*nvmlGpuInstanceGetComputeInstanceProfileInfoV)(nvmlGpuInstance_t gpuInstance, unsigned int profile, unsigned int engProfile, nvmlComputeInstanceProfileInfo_v2_t * info); + nvmlReturn_t (*nvmlGpuInstanceGetComputeInstanceRemainingCapacity)(nvmlGpuInstance_t gpuInstance, unsigned int profileId, unsigned int * count); + nvmlReturn_t (*nvmlGpuInstanceGetComputeInstancePossiblePlacements)(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstancePlacement_t * placements, unsigned int * count); + nvmlReturn_t (*nvmlGpuInstanceCreateComputeInstance)(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstance_t * computeInstance); + nvmlReturn_t (*nvmlGpuInstanceCreateComputeInstanceWithPlacement)(nvmlGpuInstance_t gpuInstance, unsigned int profileId, const nvmlComputeInstancePlacement_t * placement, nvmlComputeInstance_t * computeInstance); + nvmlReturn_t (*nvmlComputeInstanceDestroy)(nvmlComputeInstance_t computeInstance); + nvmlReturn_t (*nvmlGpuInstanceGetComputeInstances)(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstance_t * computeInstances, unsigned int * count); + nvmlReturn_t (*nvmlGpuInstanceGetComputeInstanceById)(nvmlGpuInstance_t gpuInstance, unsigned int id, nvmlComputeInstance_t * computeInstance); + nvmlReturn_t (*nvmlComputeInstanceGetInfo_v2)(nvmlComputeInstance_t computeInstance, nvmlComputeInstanceInfo_t * info); + nvmlReturn_t (*nvmlDeviceIsMigDeviceHandle)(nvmlDevice_t device, unsigned int * isMigDevice); + nvmlReturn_t (*nvmlDeviceGetGpuInstanceId)(nvmlDevice_t device, unsigned int * id); + nvmlReturn_t (*nvmlDeviceGetComputeInstanceId)(nvmlDevice_t device, unsigned int * id); + nvmlReturn_t (*nvmlDeviceGetMaxMigDeviceCount)(nvmlDevice_t device, unsigned int * count); + nvmlReturn_t (*nvmlDeviceGetMigDeviceHandleByIndex)(nvmlDevice_t device, unsigned int index, nvmlDevice_t * migDevice); + nvmlReturn_t (*nvmlDeviceGetDeviceHandleFromMigDeviceHandle)(nvmlDevice_t migDevice, nvmlDevice_t * device); + nvmlReturn_t (*nvmlGpmMetricsGet)(nvmlGpmMetricsGet_t * metricsGet); + nvmlReturn_t (*nvmlGpmSampleFree)(nvmlGpmSample_t gpmSample); + nvmlReturn_t (*nvmlGpmSampleAlloc)(nvmlGpmSample_t * gpmSample); + nvmlReturn_t (*nvmlGpmSampleGet)(nvmlDevice_t device, nvmlGpmSample_t gpmSample); + nvmlReturn_t (*nvmlGpmMigSampleGet)(nvmlDevice_t device, unsigned int gpuInstanceId, nvmlGpmSample_t gpmSample); + nvmlReturn_t (*nvmlGpmQueryDeviceSupport)(nvmlDevice_t device, nvmlGpmSupport_t * gpmSupport); + nvmlReturn_t (*nvmlGpmQueryIfStreamingEnabled)(nvmlDevice_t device, unsigned int * state); + nvmlReturn_t (*nvmlGpmSetStreamingEnabled)(nvmlDevice_t device, unsigned int state); + nvmlReturn_t (*nvmlDeviceGetCapabilities)(nvmlDevice_t device, nvmlDeviceCapabilities_t * caps); + nvmlReturn_t (*nvmlDeviceWorkloadPowerProfileGetProfilesInfo)(nvmlDevice_t device, nvmlWorkloadPowerProfileProfilesInfo_t * profilesInfo); + nvmlReturn_t (*nvmlDeviceWorkloadPowerProfileGetCurrentProfiles)(nvmlDevice_t device, nvmlWorkloadPowerProfileCurrentProfiles_t * currentProfiles); + nvmlReturn_t (*nvmlDeviceWorkloadPowerProfileSetRequestedProfiles)(nvmlDevice_t device, nvmlWorkloadPowerProfileRequestedProfiles_t * requestedProfiles); + nvmlReturn_t (*nvmlDeviceWorkloadPowerProfileClearRequestedProfiles)(nvmlDevice_t device, nvmlWorkloadPowerProfileRequestedProfiles_t * requestedProfiles); + nvmlReturn_t (*nvmlDevicePowerSmoothingActivatePresetProfile)(nvmlDevice_t device, nvmlPowerSmoothingProfile_t * profile); + nvmlReturn_t (*nvmlDevicePowerSmoothingUpdatePresetProfileParam)(nvmlDevice_t device, nvmlPowerSmoothingProfile_t * profile); + nvmlReturn_t (*nvmlDevicePowerSmoothingSetState)(nvmlDevice_t device, nvmlPowerSmoothingState_t * state); + nvmlReturn_t (*nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts)(nvmlDevice_t device, nvmlEccSramUniqueUncorrectedErrorCounts_t * errorCounts); + nvmlReturn_t (*nvmlInit)(void); + nvmlReturn_t (*nvmlDeviceGetCount)(unsigned int * deviceCount); + nvmlReturn_t (*nvmlDeviceGetHandleByIndex)(unsigned int index, nvmlDevice_t * device); + nvmlReturn_t (*nvmlDeviceGetHandleByPciBusId)(const char * pciBusId, nvmlDevice_t * device); + nvmlReturn_t (*nvmlDeviceGetPciInfo)(nvmlDevice_t device, nvmlPciInfo_t * pci); + nvmlReturn_t (*nvmlDeviceGetPciInfo_v2)(nvmlDevice_t device, nvmlPciInfo_t * pci); + nvmlReturn_t (*nvmlDeviceGetNvLinkRemotePciInfo)(nvmlDevice_t device, unsigned int link, nvmlPciInfo_t * pci); + nvmlReturn_t (*nvmlDeviceGetGridLicensableFeatures)(nvmlDevice_t device, nvmlGridLicensableFeatures_t * pGridLicensableFeatures); + nvmlReturn_t (*nvmlDeviceGetGridLicensableFeatures_v2)(nvmlDevice_t device, nvmlGridLicensableFeatures_t * pGridLicensableFeatures); + nvmlReturn_t (*nvmlDeviceGetGridLicensableFeatures_v3)(nvmlDevice_t device, nvmlGridLicensableFeatures_t * pGridLicensableFeatures); + nvmlReturn_t (*nvmlDeviceRemoveGpu)(nvmlPciInfo_t * pciInfo); + nvmlReturn_t (*nvmlEventSetWait)(nvmlEventSet_t set, nvmlEventData_t * data, unsigned int timeoutms); + nvmlReturn_t (*nvmlDeviceGetAttributes)(nvmlDevice_t device, nvmlDeviceAttributes_t * attributes); + nvmlReturn_t (*nvmlComputeInstanceGetInfo)(nvmlComputeInstance_t computeInstance, nvmlComputeInstanceInfo_t * info); + nvmlReturn_t (*nvmlDeviceGetComputeRunningProcesses)(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_v1_t * infos); + nvmlReturn_t (*nvmlDeviceGetComputeRunningProcesses_v2)(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_v2_t * infos); + nvmlReturn_t (*nvmlDeviceGetGraphicsRunningProcesses)(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_v1_t * infos); + nvmlReturn_t (*nvmlDeviceGetGraphicsRunningProcesses_v2)(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_v2_t * infos); + nvmlReturn_t (*nvmlDeviceGetMPSComputeRunningProcesses)(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_v1_t * infos); + nvmlReturn_t (*nvmlDeviceGetMPSComputeRunningProcesses_v2)(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_v2_t * infos); + nvmlReturn_t (*nvmlDeviceGetGpuInstancePossiblePlacements)(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstancePlacement_t * placements, unsigned int * count); + nvmlReturn_t (*nvmlVgpuInstanceGetLicenseInfo)(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuLicenseInfo_t * licenseInfo); + nvmlReturn_t (*nvmlDeviceGetDriverModel)(nvmlDevice_t device, nvmlDriverModel_t * current, nvmlDriverModel_t * pending); + +} nvml_dispatch_t; + +extern nvml_dispatch_t nvml_dispatch; + +// Static inline wrappers — cgo calls these instead of the NVML symbols directly, +// routing through the dispatch table rather than the PLT. +static inline nvmlReturn_t dispatch_nvmlInit_v2(void) { + if (!nvml_dispatch.nvmlInit_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlInit_v2(); +} + +static inline nvmlReturn_t dispatch_nvmlInitWithFlags(unsigned int flags) { + if (!nvml_dispatch.nvmlInitWithFlags) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlInitWithFlags(flags); +} + +static inline nvmlReturn_t dispatch_nvmlShutdown(void) { + if (!nvml_dispatch.nvmlShutdown) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlShutdown(); +} + +static inline const char* dispatch_nvmlErrorString(nvmlReturn_t result) { + if (!nvml_dispatch.nvmlErrorString) return (const char*)0; + return nvml_dispatch.nvmlErrorString(result); +} + +static inline nvmlReturn_t dispatch_nvmlSystemGetDriverVersion(char * version, unsigned int length) { + if (!nvml_dispatch.nvmlSystemGetDriverVersion) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemGetDriverVersion(version, length); +} + +static inline nvmlReturn_t dispatch_nvmlSystemGetNVMLVersion(char * version, unsigned int length) { + if (!nvml_dispatch.nvmlSystemGetNVMLVersion) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemGetNVMLVersion(version, length); +} + +static inline nvmlReturn_t dispatch_nvmlSystemGetCudaDriverVersion(int * cudaDriverVersion) { + if (!nvml_dispatch.nvmlSystemGetCudaDriverVersion) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemGetCudaDriverVersion(cudaDriverVersion); +} + +static inline nvmlReturn_t dispatch_nvmlSystemGetCudaDriverVersion_v2(int * cudaDriverVersion) { + if (!nvml_dispatch.nvmlSystemGetCudaDriverVersion_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemGetCudaDriverVersion_v2(cudaDriverVersion); +} + +static inline nvmlReturn_t dispatch_nvmlSystemGetProcessName(unsigned int pid, char * name, unsigned int length) { + if (!nvml_dispatch.nvmlSystemGetProcessName) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemGetProcessName(pid, name, length); +} + +static inline nvmlReturn_t dispatch_nvmlSystemGetHicVersion(unsigned int * hwbcCount, nvmlHwbcEntry_t * hwbcEntries) { + if (!nvml_dispatch.nvmlSystemGetHicVersion) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemGetHicVersion(hwbcCount, hwbcEntries); +} + +static inline nvmlReturn_t dispatch_nvmlSystemGetTopologyGpuSet(unsigned int cpuNumber, unsigned int * count, nvmlDevice_t * deviceArray) { + if (!nvml_dispatch.nvmlSystemGetTopologyGpuSet) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemGetTopologyGpuSet(cpuNumber, count, deviceArray); +} + +static inline nvmlReturn_t dispatch_nvmlSystemGetDriverBranch(nvmlSystemDriverBranchInfo_t * branchInfo, unsigned int length) { + if (!nvml_dispatch.nvmlSystemGetDriverBranch) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemGetDriverBranch(branchInfo, length); +} + +static inline nvmlReturn_t dispatch_nvmlUnitGetCount(unsigned int * unitCount) { + if (!nvml_dispatch.nvmlUnitGetCount) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlUnitGetCount(unitCount); +} + +static inline nvmlReturn_t dispatch_nvmlUnitGetHandleByIndex(unsigned int index, nvmlUnit_t * unit) { + if (!nvml_dispatch.nvmlUnitGetHandleByIndex) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlUnitGetHandleByIndex(index, unit); +} + +static inline nvmlReturn_t dispatch_nvmlUnitGetUnitInfo(nvmlUnit_t unit, nvmlUnitInfo_t * info) { + if (!nvml_dispatch.nvmlUnitGetUnitInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlUnitGetUnitInfo(unit, info); +} + +static inline nvmlReturn_t dispatch_nvmlUnitGetLedState(nvmlUnit_t unit, nvmlLedState_t * state) { + if (!nvml_dispatch.nvmlUnitGetLedState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlUnitGetLedState(unit, state); +} + +static inline nvmlReturn_t dispatch_nvmlUnitGetPsuInfo(nvmlUnit_t unit, nvmlPSUInfo_t * psu) { + if (!nvml_dispatch.nvmlUnitGetPsuInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlUnitGetPsuInfo(unit, psu); +} + +static inline nvmlReturn_t dispatch_nvmlUnitGetTemperature(nvmlUnit_t unit, unsigned int type, unsigned int * temp) { + if (!nvml_dispatch.nvmlUnitGetTemperature) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlUnitGetTemperature(unit, type, temp); +} + +static inline nvmlReturn_t dispatch_nvmlUnitGetFanSpeedInfo(nvmlUnit_t unit, nvmlUnitFanSpeeds_t * fanSpeeds) { + if (!nvml_dispatch.nvmlUnitGetFanSpeedInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlUnitGetFanSpeedInfo(unit, fanSpeeds); +} + +static inline nvmlReturn_t dispatch_nvmlUnitGetDevices(nvmlUnit_t unit, unsigned int * deviceCount, nvmlDevice_t * devices) { + if (!nvml_dispatch.nvmlUnitGetDevices) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlUnitGetDevices(unit, deviceCount, devices); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetCount_v2(unsigned int * deviceCount) { + if (!nvml_dispatch.nvmlDeviceGetCount_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetCount_v2(deviceCount); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetAttributes_v2(nvmlDevice_t device, nvmlDeviceAttributes_t * attributes) { + if (!nvml_dispatch.nvmlDeviceGetAttributes_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetAttributes_v2(device, attributes); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetHandleByIndex_v2(unsigned int index, nvmlDevice_t * device) { + if (!nvml_dispatch.nvmlDeviceGetHandleByIndex_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetHandleByIndex_v2(index, device); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetHandleBySerial(const char * serial, nvmlDevice_t * device) { + if (!nvml_dispatch.nvmlDeviceGetHandleBySerial) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetHandleBySerial(serial, device); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetHandleByUUID(const char * uuid, nvmlDevice_t * device) { + if (!nvml_dispatch.nvmlDeviceGetHandleByUUID) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetHandleByUUID(uuid, device); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetHandleByUUIDV(const nvmlUUID_t * uuid, nvmlDevice_t * device) { + if (!nvml_dispatch.nvmlDeviceGetHandleByUUIDV) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetHandleByUUIDV(uuid, device); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetHandleByPciBusId_v2(const char * pciBusId, nvmlDevice_t * device) { + if (!nvml_dispatch.nvmlDeviceGetHandleByPciBusId_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetHandleByPciBusId_v2(pciBusId, device); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetName(nvmlDevice_t device, char * name, unsigned int length) { + if (!nvml_dispatch.nvmlDeviceGetName) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetName(device, name, length); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetBrand(nvmlDevice_t device, nvmlBrandType_t * type) { + if (!nvml_dispatch.nvmlDeviceGetBrand) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetBrand(device, type); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetIndex(nvmlDevice_t device, unsigned int * index) { + if (!nvml_dispatch.nvmlDeviceGetIndex) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetIndex(device, index); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetSerial(nvmlDevice_t device, char * serial, unsigned int length) { + if (!nvml_dispatch.nvmlDeviceGetSerial) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetSerial(device, serial, length); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetModuleId(nvmlDevice_t device, unsigned int * moduleId) { + if (!nvml_dispatch.nvmlDeviceGetModuleId) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetModuleId(device, moduleId); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetC2cModeInfoV(nvmlDevice_t device, nvmlC2cModeInfo_v1_t * c2cModeInfo) { + if (!nvml_dispatch.nvmlDeviceGetC2cModeInfoV) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetC2cModeInfoV(device, c2cModeInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMemoryAffinity(nvmlDevice_t device, unsigned int nodeSetSize, unsigned long * nodeSet, nvmlAffinityScope_t scope) { + if (!nvml_dispatch.nvmlDeviceGetMemoryAffinity) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMemoryAffinity(device, nodeSetSize, nodeSet, scope); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetCpuAffinityWithinScope(nvmlDevice_t device, unsigned int cpuSetSize, unsigned long * cpuSet, nvmlAffinityScope_t scope) { + if (!nvml_dispatch.nvmlDeviceGetCpuAffinityWithinScope) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetCpuAffinityWithinScope(device, cpuSetSize, cpuSet, scope); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetCpuAffinity(nvmlDevice_t device, unsigned int cpuSetSize, unsigned long * cpuSet) { + if (!nvml_dispatch.nvmlDeviceGetCpuAffinity) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetCpuAffinity(device, cpuSetSize, cpuSet); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetCpuAffinity(nvmlDevice_t device) { + if (!nvml_dispatch.nvmlDeviceSetCpuAffinity) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetCpuAffinity(device); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceClearCpuAffinity(nvmlDevice_t device) { + if (!nvml_dispatch.nvmlDeviceClearCpuAffinity) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceClearCpuAffinity(device); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNumaNodeId(nvmlDevice_t device, unsigned int * node) { + if (!nvml_dispatch.nvmlDeviceGetNumaNodeId) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNumaNodeId(device, node); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetAddressingMode(nvmlDevice_t device, nvmlDeviceAddressingMode_t * mode) { + if (!nvml_dispatch.nvmlDeviceGetAddressingMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetAddressingMode(device, mode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetRepairStatus(nvmlDevice_t device, nvmlRepairStatus_t * repairStatus) { + if (!nvml_dispatch.nvmlDeviceGetRepairStatus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetRepairStatus(device, repairStatus); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetTopologyCommonAncestor(nvmlDevice_t device1, nvmlDevice_t device2, nvmlGpuTopologyLevel_t * pathInfo) { + if (!nvml_dispatch.nvmlDeviceGetTopologyCommonAncestor) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetTopologyCommonAncestor(device1, device2, pathInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetTopologyNearestGpus(nvmlDevice_t device, nvmlGpuTopologyLevel_t level, unsigned int * count, nvmlDevice_t * deviceArray) { + if (!nvml_dispatch.nvmlDeviceGetTopologyNearestGpus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetTopologyNearestGpus(device, level, count, deviceArray); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetP2PStatus(nvmlDevice_t device1, nvmlDevice_t device2, nvmlGpuP2PCapsIndex_t p2pIndex, nvmlGpuP2PStatus_t * p2pStatus) { + if (!nvml_dispatch.nvmlDeviceGetP2PStatus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetP2PStatus(device1, device2, p2pIndex, p2pStatus); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetUUID(nvmlDevice_t device, char * uuid, unsigned int length) { + if (!nvml_dispatch.nvmlDeviceGetUUID) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetUUID(device, uuid, length); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMinorNumber(nvmlDevice_t device, unsigned int * minorNumber) { + if (!nvml_dispatch.nvmlDeviceGetMinorNumber) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMinorNumber(device, minorNumber); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetBoardPartNumber(nvmlDevice_t device, char* partNumber, unsigned int length) { + if (!nvml_dispatch.nvmlDeviceGetBoardPartNumber) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetBoardPartNumber(device, partNumber, length); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetInforomVersion(nvmlDevice_t device, nvmlInforomObject_t object, char * version, unsigned int length) { + if (!nvml_dispatch.nvmlDeviceGetInforomVersion) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetInforomVersion(device, object, version, length); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetInforomImageVersion(nvmlDevice_t device, char * version, unsigned int length) { + if (!nvml_dispatch.nvmlDeviceGetInforomImageVersion) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetInforomImageVersion(device, version, length); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetInforomConfigurationChecksum(nvmlDevice_t device, unsigned int * checksum) { + if (!nvml_dispatch.nvmlDeviceGetInforomConfigurationChecksum) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetInforomConfigurationChecksum(device, checksum); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceValidateInforom(nvmlDevice_t device) { + if (!nvml_dispatch.nvmlDeviceValidateInforom) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceValidateInforom(device); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetLastBBXFlushTime(nvmlDevice_t device, unsigned long long * timestamp, unsigned long * durationUs) { + if (!nvml_dispatch.nvmlDeviceGetLastBBXFlushTime) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetLastBBXFlushTime(device, timestamp, durationUs); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetDisplayMode(nvmlDevice_t device, nvmlEnableState_t * display) { + if (!nvml_dispatch.nvmlDeviceGetDisplayMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetDisplayMode(device, display); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetDisplayActive(nvmlDevice_t device, nvmlEnableState_t * isActive) { + if (!nvml_dispatch.nvmlDeviceGetDisplayActive) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetDisplayActive(device, isActive); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPersistenceMode(nvmlDevice_t device, nvmlEnableState_t * mode) { + if (!nvml_dispatch.nvmlDeviceGetPersistenceMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPersistenceMode(device, mode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPciInfoExt(nvmlDevice_t device, nvmlPciInfoExt_t * pci) { + if (!nvml_dispatch.nvmlDeviceGetPciInfoExt) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPciInfoExt(device, pci); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPciInfo_v3(nvmlDevice_t device, nvmlPciInfo_t * pci) { + if (!nvml_dispatch.nvmlDeviceGetPciInfo_v3) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPciInfo_v3(device, pci); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMaxPcieLinkGeneration(nvmlDevice_t device, unsigned int * maxLinkGen) { + if (!nvml_dispatch.nvmlDeviceGetMaxPcieLinkGeneration) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMaxPcieLinkGeneration(device, maxLinkGen); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpuMaxPcieLinkGeneration(nvmlDevice_t device, unsigned int * maxLinkGenDevice) { + if (!nvml_dispatch.nvmlDeviceGetGpuMaxPcieLinkGeneration) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpuMaxPcieLinkGeneration(device, maxLinkGenDevice); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMaxPcieLinkWidth(nvmlDevice_t device, unsigned int * maxLinkWidth) { + if (!nvml_dispatch.nvmlDeviceGetMaxPcieLinkWidth) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMaxPcieLinkWidth(device, maxLinkWidth); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetCurrPcieLinkGeneration(nvmlDevice_t device, unsigned int * currLinkGen) { + if (!nvml_dispatch.nvmlDeviceGetCurrPcieLinkGeneration) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetCurrPcieLinkGeneration(device, currLinkGen); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetCurrPcieLinkWidth(nvmlDevice_t device, unsigned int * currLinkWidth) { + if (!nvml_dispatch.nvmlDeviceGetCurrPcieLinkWidth) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetCurrPcieLinkWidth(device, currLinkWidth); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPcieThroughput(nvmlDevice_t device, nvmlPcieUtilCounter_t counter, unsigned int * value) { + if (!nvml_dispatch.nvmlDeviceGetPcieThroughput) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPcieThroughput(device, counter, value); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPcieReplayCounter(nvmlDevice_t device, unsigned int * value) { + if (!nvml_dispatch.nvmlDeviceGetPcieReplayCounter) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPcieReplayCounter(device, value); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetClockInfo(nvmlDevice_t device, nvmlClockType_t type, unsigned int * clock) { + if (!nvml_dispatch.nvmlDeviceGetClockInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetClockInfo(device, type, clock); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMaxClockInfo(nvmlDevice_t device, nvmlClockType_t type, unsigned int * clock) { + if (!nvml_dispatch.nvmlDeviceGetMaxClockInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMaxClockInfo(device, type, clock); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpcClkVfOffset(nvmlDevice_t device, int * offset) { + if (!nvml_dispatch.nvmlDeviceGetGpcClkVfOffset) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpcClkVfOffset(device, offset); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetApplicationsClock(nvmlDevice_t device, nvmlClockType_t clockType, unsigned int * clockMHz) { + if (!nvml_dispatch.nvmlDeviceGetApplicationsClock) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetApplicationsClock(device, clockType, clockMHz); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetDefaultApplicationsClock(nvmlDevice_t device, nvmlClockType_t clockType, unsigned int * clockMHz) { + if (!nvml_dispatch.nvmlDeviceGetDefaultApplicationsClock) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetDefaultApplicationsClock(device, clockType, clockMHz); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetClock(nvmlDevice_t device, nvmlClockType_t clockType, nvmlClockId_t clockId, unsigned int * clockMHz) { + if (!nvml_dispatch.nvmlDeviceGetClock) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetClock(device, clockType, clockId, clockMHz); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMaxCustomerBoostClock(nvmlDevice_t device, nvmlClockType_t clockType, unsigned int * clockMHz) { + if (!nvml_dispatch.nvmlDeviceGetMaxCustomerBoostClock) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMaxCustomerBoostClock(device, clockType, clockMHz); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetSupportedMemoryClocks(nvmlDevice_t device, unsigned int * count, unsigned int * clocksMHz) { + if (!nvml_dispatch.nvmlDeviceGetSupportedMemoryClocks) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetSupportedMemoryClocks(device, count, clocksMHz); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetSupportedGraphicsClocks(nvmlDevice_t device, unsigned int memoryClockMHz, unsigned int * count, unsigned int * clocksMHz) { + if (!nvml_dispatch.nvmlDeviceGetSupportedGraphicsClocks) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetSupportedGraphicsClocks(device, memoryClockMHz, count, clocksMHz); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t * isEnabled, nvmlEnableState_t * defaultIsEnabled) { + if (!nvml_dispatch.nvmlDeviceGetAutoBoostedClocksEnabled) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetAutoBoostedClocksEnabled(device, isEnabled, defaultIsEnabled); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetFanSpeed(nvmlDevice_t device, unsigned int * speed) { + if (!nvml_dispatch.nvmlDeviceGetFanSpeed) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetFanSpeed(device, speed); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetFanSpeed_v2(nvmlDevice_t device, unsigned int fan, unsigned int * speed) { + if (!nvml_dispatch.nvmlDeviceGetFanSpeed_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetFanSpeed_v2(device, fan, speed); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetFanSpeedRPM(nvmlDevice_t device, nvmlFanSpeedInfo_t * fanSpeed) { + if (!nvml_dispatch.nvmlDeviceGetFanSpeedRPM) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetFanSpeedRPM(device, fanSpeed); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetTargetFanSpeed(nvmlDevice_t device, unsigned int fan, unsigned int * targetSpeed) { + if (!nvml_dispatch.nvmlDeviceGetTargetFanSpeed) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetTargetFanSpeed(device, fan, targetSpeed); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMinMaxFanSpeed(nvmlDevice_t device, unsigned int * minSpeed, unsigned int * maxSpeed) { + if (!nvml_dispatch.nvmlDeviceGetMinMaxFanSpeed) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMinMaxFanSpeed(device, minSpeed, maxSpeed); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetFanControlPolicy_v2(nvmlDevice_t device, unsigned int fan, nvmlFanControlPolicy_t * policy) { + if (!nvml_dispatch.nvmlDeviceGetFanControlPolicy_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetFanControlPolicy_v2(device, fan, policy); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNumFans(nvmlDevice_t device, unsigned int * numFans) { + if (!nvml_dispatch.nvmlDeviceGetNumFans) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNumFans(device, numFans); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetTemperature(nvmlDevice_t device, nvmlTemperatureSensors_t sensorType, unsigned int * temp) { + if (!nvml_dispatch.nvmlDeviceGetTemperature) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetTemperature(device, sensorType, temp); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetCoolerInfo(nvmlDevice_t device, nvmlCoolerInfo_t * coolerInfo) { + if (!nvml_dispatch.nvmlDeviceGetCoolerInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetCoolerInfo(device, coolerInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetTemperatureV(nvmlDevice_t device, nvmlTemperature_t * temperature) { + if (!nvml_dispatch.nvmlDeviceGetTemperatureV) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetTemperatureV(device, temperature); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetTemperatureThreshold(nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, unsigned int * temp) { + if (!nvml_dispatch.nvmlDeviceGetTemperatureThreshold) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetTemperatureThreshold(device, thresholdType, temp); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMarginTemperature(nvmlDevice_t device, nvmlMarginTemperature_t * marginTempInfo) { + if (!nvml_dispatch.nvmlDeviceGetMarginTemperature) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMarginTemperature(device, marginTempInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetThermalSettings(nvmlDevice_t device, unsigned int sensorIndex, nvmlGpuThermalSettings_t * pThermalSettings) { + if (!nvml_dispatch.nvmlDeviceGetThermalSettings) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetThermalSettings(device, sensorIndex, pThermalSettings); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPerformanceState(nvmlDevice_t device, nvmlPstates_t * pState) { + if (!nvml_dispatch.nvmlDeviceGetPerformanceState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPerformanceState(device, pState); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetCurrentClocksEventReasons(nvmlDevice_t device, unsigned long long * clocksEventReasons) { + if (!nvml_dispatch.nvmlDeviceGetCurrentClocksEventReasons) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetCurrentClocksEventReasons(device, clocksEventReasons); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetCurrentClocksThrottleReasons(nvmlDevice_t device, unsigned long long * clocksThrottleReasons) { + if (!nvml_dispatch.nvmlDeviceGetCurrentClocksThrottleReasons) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetCurrentClocksThrottleReasons(device, clocksThrottleReasons); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetSupportedClocksEventReasons(nvmlDevice_t device, unsigned long long * supportedClocksEventReasons) { + if (!nvml_dispatch.nvmlDeviceGetSupportedClocksEventReasons) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetSupportedClocksEventReasons(device, supportedClocksEventReasons); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetSupportedClocksThrottleReasons(nvmlDevice_t device, unsigned long long * supportedClocksThrottleReasons) { + if (!nvml_dispatch.nvmlDeviceGetSupportedClocksThrottleReasons) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetSupportedClocksThrottleReasons(device, supportedClocksThrottleReasons); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPowerState(nvmlDevice_t device, nvmlPstates_t * pState) { + if (!nvml_dispatch.nvmlDeviceGetPowerState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPowerState(device, pState); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetDynamicPstatesInfo(nvmlDevice_t device, nvmlGpuDynamicPstatesInfo_t * pDynamicPstatesInfo) { + if (!nvml_dispatch.nvmlDeviceGetDynamicPstatesInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetDynamicPstatesInfo(device, pDynamicPstatesInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMemClkVfOffset(nvmlDevice_t device, int * offset) { + if (!nvml_dispatch.nvmlDeviceGetMemClkVfOffset) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMemClkVfOffset(device, offset); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMinMaxClockOfPState(nvmlDevice_t device, nvmlClockType_t type, nvmlPstates_t pstate, unsigned int * minClockMHz, unsigned int * maxClockMHz) { + if (!nvml_dispatch.nvmlDeviceGetMinMaxClockOfPState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMinMaxClockOfPState(device, type, pstate, minClockMHz, maxClockMHz); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetSupportedPerformanceStates(nvmlDevice_t device, nvmlPstates_t * pstates, unsigned int size) { + if (!nvml_dispatch.nvmlDeviceGetSupportedPerformanceStates) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetSupportedPerformanceStates(device, pstates, size); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpcClkMinMaxVfOffset(nvmlDevice_t device, int * minOffset, int * maxOffset) { + if (!nvml_dispatch.nvmlDeviceGetGpcClkMinMaxVfOffset) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpcClkMinMaxVfOffset(device, minOffset, maxOffset); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMemClkMinMaxVfOffset(nvmlDevice_t device, int * minOffset, int * maxOffset) { + if (!nvml_dispatch.nvmlDeviceGetMemClkMinMaxVfOffset) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMemClkMinMaxVfOffset(device, minOffset, maxOffset); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetClockOffsets(nvmlDevice_t device, nvmlClockOffset_t * info) { + if (!nvml_dispatch.nvmlDeviceGetClockOffsets) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetClockOffsets(device, info); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetClockOffsets(nvmlDevice_t device, nvmlClockOffset_t * info) { + if (!nvml_dispatch.nvmlDeviceSetClockOffsets) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetClockOffsets(device, info); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPerformanceModes(nvmlDevice_t device, nvmlDevicePerfModes_t * perfModes) { + if (!nvml_dispatch.nvmlDeviceGetPerformanceModes) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPerformanceModes(device, perfModes); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetCurrentClockFreqs(nvmlDevice_t device, nvmlDeviceCurrentClockFreqs_t * currentClockFreqs) { + if (!nvml_dispatch.nvmlDeviceGetCurrentClockFreqs) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetCurrentClockFreqs(device, currentClockFreqs); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPowerManagementMode(nvmlDevice_t device, nvmlEnableState_t * mode) { + if (!nvml_dispatch.nvmlDeviceGetPowerManagementMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPowerManagementMode(device, mode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPowerManagementLimit(nvmlDevice_t device, unsigned int * limit) { + if (!nvml_dispatch.nvmlDeviceGetPowerManagementLimit) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPowerManagementLimit(device, limit); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPowerManagementLimitConstraints(nvmlDevice_t device, unsigned int * minLimit, unsigned int * maxLimit) { + if (!nvml_dispatch.nvmlDeviceGetPowerManagementLimitConstraints) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPowerManagementLimitConstraints(device, minLimit, maxLimit); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPowerManagementDefaultLimit(nvmlDevice_t device, unsigned int * defaultLimit) { + if (!nvml_dispatch.nvmlDeviceGetPowerManagementDefaultLimit) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPowerManagementDefaultLimit(device, defaultLimit); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPowerUsage(nvmlDevice_t device, unsigned int * power) { + if (!nvml_dispatch.nvmlDeviceGetPowerUsage) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPowerUsage(device, power); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPowerMizerMode_v1(nvmlDevice_t device, nvmlDevicePowerMizerModes_v1_t * powerMizerMode) { + if (!nvml_dispatch.nvmlDeviceGetPowerMizerMode_v1) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPowerMizerMode_v1(device, powerMizerMode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetPowerMizerMode_v1(nvmlDevice_t device, nvmlDevicePowerMizerModes_v1_t * powerMizerMode) { + if (!nvml_dispatch.nvmlDeviceSetPowerMizerMode_v1) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetPowerMizerMode_v1(device, powerMizerMode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetTotalEnergyConsumption(nvmlDevice_t device, unsigned long long * energy) { + if (!nvml_dispatch.nvmlDeviceGetTotalEnergyConsumption) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetTotalEnergyConsumption(device, energy); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetEnforcedPowerLimit(nvmlDevice_t device, unsigned int * limit) { + if (!nvml_dispatch.nvmlDeviceGetEnforcedPowerLimit) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetEnforcedPowerLimit(device, limit); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpuOperationMode(nvmlDevice_t device, nvmlGpuOperationMode_t * current, nvmlGpuOperationMode_t * pending) { + if (!nvml_dispatch.nvmlDeviceGetGpuOperationMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpuOperationMode(device, current, pending); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMemoryInfo(nvmlDevice_t device, nvmlMemory_t * memory) { + if (!nvml_dispatch.nvmlDeviceGetMemoryInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMemoryInfo(device, memory); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMemoryInfo_v2(nvmlDevice_t device, nvmlMemory_v2_t * memory) { + if (!nvml_dispatch.nvmlDeviceGetMemoryInfo_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMemoryInfo_v2(device, memory); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetComputeMode(nvmlDevice_t device, nvmlComputeMode_t * mode) { + if (!nvml_dispatch.nvmlDeviceGetComputeMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetComputeMode(device, mode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetCudaComputeCapability(nvmlDevice_t device, int * major, int * minor) { + if (!nvml_dispatch.nvmlDeviceGetCudaComputeCapability) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetCudaComputeCapability(device, major, minor); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetDramEncryptionMode(nvmlDevice_t device, nvmlDramEncryptionInfo_t * current, nvmlDramEncryptionInfo_t * pending) { + if (!nvml_dispatch.nvmlDeviceGetDramEncryptionMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetDramEncryptionMode(device, current, pending); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetDramEncryptionMode(nvmlDevice_t device, const nvmlDramEncryptionInfo_t * dramEncryption) { + if (!nvml_dispatch.nvmlDeviceSetDramEncryptionMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetDramEncryptionMode(device, dramEncryption); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetEccMode(nvmlDevice_t device, nvmlEnableState_t * current, nvmlEnableState_t * pending) { + if (!nvml_dispatch.nvmlDeviceGetEccMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetEccMode(device, current, pending); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetDefaultEccMode(nvmlDevice_t device, nvmlEnableState_t * defaultMode) { + if (!nvml_dispatch.nvmlDeviceGetDefaultEccMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetDefaultEccMode(device, defaultMode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetBoardId(nvmlDevice_t device, unsigned int * boardId) { + if (!nvml_dispatch.nvmlDeviceGetBoardId) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetBoardId(device, boardId); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMultiGpuBoard(nvmlDevice_t device, unsigned int * multiGpuBool) { + if (!nvml_dispatch.nvmlDeviceGetMultiGpuBoard) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMultiGpuBoard(device, multiGpuBool); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetTotalEccErrors(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, unsigned long long * eccCounts) { + if (!nvml_dispatch.nvmlDeviceGetTotalEccErrors) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetTotalEccErrors(device, errorType, counterType, eccCounts); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetDetailedEccErrors(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, nvmlEccErrorCounts_t * eccCounts) { + if (!nvml_dispatch.nvmlDeviceGetDetailedEccErrors) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetDetailedEccErrors(device, errorType, counterType, eccCounts); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMemoryErrorCounter(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, nvmlMemoryLocation_t locationType, unsigned long long * count) { + if (!nvml_dispatch.nvmlDeviceGetMemoryErrorCounter) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMemoryErrorCounter(device, errorType, counterType, locationType, count); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetUtilizationRates(nvmlDevice_t device, nvmlUtilization_t * utilization) { + if (!nvml_dispatch.nvmlDeviceGetUtilizationRates) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetUtilizationRates(device, utilization); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetEncoderUtilization(nvmlDevice_t device, unsigned int * utilization, unsigned int * samplingPeriodUs) { + if (!nvml_dispatch.nvmlDeviceGetEncoderUtilization) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetEncoderUtilization(device, utilization, samplingPeriodUs); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetEncoderCapacity(nvmlDevice_t device, nvmlEncoderType_t encoderQueryType, unsigned int * encoderCapacity) { + if (!nvml_dispatch.nvmlDeviceGetEncoderCapacity) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetEncoderCapacity(device, encoderQueryType, encoderCapacity); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetEncoderStats(nvmlDevice_t device, unsigned int * sessionCount, unsigned int * averageFps, unsigned int * averageLatency) { + if (!nvml_dispatch.nvmlDeviceGetEncoderStats) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetEncoderStats(device, sessionCount, averageFps, averageLatency); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetEncoderSessions(nvmlDevice_t device, unsigned int * sessionCount, nvmlEncoderSessionInfo_t * sessionInfos) { + if (!nvml_dispatch.nvmlDeviceGetEncoderSessions) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetEncoderSessions(device, sessionCount, sessionInfos); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetDecoderUtilization(nvmlDevice_t device, unsigned int * utilization, unsigned int * samplingPeriodUs) { + if (!nvml_dispatch.nvmlDeviceGetDecoderUtilization) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetDecoderUtilization(device, utilization, samplingPeriodUs); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetJpgUtilization(nvmlDevice_t device, unsigned int * utilization, unsigned int * samplingPeriodUs) { + if (!nvml_dispatch.nvmlDeviceGetJpgUtilization) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetJpgUtilization(device, utilization, samplingPeriodUs); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetOfaUtilization(nvmlDevice_t device, unsigned int * utilization, unsigned int * samplingPeriodUs) { + if (!nvml_dispatch.nvmlDeviceGetOfaUtilization) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetOfaUtilization(device, utilization, samplingPeriodUs); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetFBCStats(nvmlDevice_t device, nvmlFBCStats_t * fbcStats) { + if (!nvml_dispatch.nvmlDeviceGetFBCStats) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetFBCStats(device, fbcStats); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetFBCSessions(nvmlDevice_t device, unsigned int * sessionCount, nvmlFBCSessionInfo_t * sessionInfo) { + if (!nvml_dispatch.nvmlDeviceGetFBCSessions) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetFBCSessions(device, sessionCount, sessionInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetDriverModel_v2(nvmlDevice_t device, nvmlDriverModel_t * current, nvmlDriverModel_t * pending) { + if (!nvml_dispatch.nvmlDeviceGetDriverModel_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetDriverModel_v2(device, current, pending); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetVbiosVersion(nvmlDevice_t device, char * version, unsigned int length) { + if (!nvml_dispatch.nvmlDeviceGetVbiosVersion) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetVbiosVersion(device, version, length); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetBridgeChipInfo(nvmlDevice_t device, nvmlBridgeChipHierarchy_t * bridgeHierarchy) { + if (!nvml_dispatch.nvmlDeviceGetBridgeChipInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetBridgeChipInfo(device, bridgeHierarchy); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetComputeRunningProcesses_v3(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_t * infos) { + if (!nvml_dispatch.nvmlDeviceGetComputeRunningProcesses_v3) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetComputeRunningProcesses_v3(device, infoCount, infos); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGraphicsRunningProcesses_v3(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_t * infos) { + if (!nvml_dispatch.nvmlDeviceGetGraphicsRunningProcesses_v3) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGraphicsRunningProcesses_v3(device, infoCount, infos); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMPSComputeRunningProcesses_v3(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_t * infos) { + if (!nvml_dispatch.nvmlDeviceGetMPSComputeRunningProcesses_v3) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMPSComputeRunningProcesses_v3(device, infoCount, infos); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetRunningProcessDetailList(nvmlDevice_t device, nvmlProcessDetailList_t * plist) { + if (!nvml_dispatch.nvmlDeviceGetRunningProcessDetailList) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetRunningProcessDetailList(device, plist); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceOnSameBoard(nvmlDevice_t device1, nvmlDevice_t device2, int * onSameBoard) { + if (!nvml_dispatch.nvmlDeviceOnSameBoard) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceOnSameBoard(device1, device2, onSameBoard); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetAPIRestriction(nvmlDevice_t device, nvmlRestrictedAPI_t apiType, nvmlEnableState_t * isRestricted) { + if (!nvml_dispatch.nvmlDeviceGetAPIRestriction) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetAPIRestriction(device, apiType, isRestricted); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetSamples(nvmlDevice_t device, nvmlSamplingType_t type, unsigned long long lastSeenTimeStamp, nvmlValueType_t * sampleValType, unsigned int * sampleCount, nvmlSample_t * samples) { + if (!nvml_dispatch.nvmlDeviceGetSamples) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetSamples(device, type, lastSeenTimeStamp, sampleValType, sampleCount, samples); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetBAR1MemoryInfo(nvmlDevice_t device, nvmlBAR1Memory_t * bar1Memory) { + if (!nvml_dispatch.nvmlDeviceGetBAR1MemoryInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetBAR1MemoryInfo(device, bar1Memory); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetViolationStatus(nvmlDevice_t device, nvmlPerfPolicyType_t perfPolicyType, nvmlViolationTime_t * violTime) { + if (!nvml_dispatch.nvmlDeviceGetViolationStatus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetViolationStatus(device, perfPolicyType, violTime); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetIrqNum(nvmlDevice_t device, unsigned int * irqNum) { + if (!nvml_dispatch.nvmlDeviceGetIrqNum) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetIrqNum(device, irqNum); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNumGpuCores(nvmlDevice_t device, unsigned int * numCores) { + if (!nvml_dispatch.nvmlDeviceGetNumGpuCores) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNumGpuCores(device, numCores); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPowerSource(nvmlDevice_t device, nvmlPowerSource_t * powerSource) { + if (!nvml_dispatch.nvmlDeviceGetPowerSource) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPowerSource(device, powerSource); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMemoryBusWidth(nvmlDevice_t device, unsigned int * busWidth) { + if (!nvml_dispatch.nvmlDeviceGetMemoryBusWidth) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMemoryBusWidth(device, busWidth); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPcieLinkMaxSpeed(nvmlDevice_t device, unsigned int * maxSpeed) { + if (!nvml_dispatch.nvmlDeviceGetPcieLinkMaxSpeed) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPcieLinkMaxSpeed(device, maxSpeed); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPcieSpeed(nvmlDevice_t device, unsigned int * pcieSpeed) { + if (!nvml_dispatch.nvmlDeviceGetPcieSpeed) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPcieSpeed(device, pcieSpeed); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetAdaptiveClockInfoStatus(nvmlDevice_t device, unsigned int * adaptiveClockStatus) { + if (!nvml_dispatch.nvmlDeviceGetAdaptiveClockInfoStatus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetAdaptiveClockInfoStatus(device, adaptiveClockStatus); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetBusType(nvmlDevice_t device, nvmlBusType_t * type) { + if (!nvml_dispatch.nvmlDeviceGetBusType) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetBusType(device, type); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpuFabricInfo(nvmlDevice_t device, nvmlGpuFabricInfo_t * gpuFabricInfo) { + if (!nvml_dispatch.nvmlDeviceGetGpuFabricInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpuFabricInfo(device, gpuFabricInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpuFabricInfoV(nvmlDevice_t device, nvmlGpuFabricInfoV_t * gpuFabricInfo) { + if (!nvml_dispatch.nvmlDeviceGetGpuFabricInfoV) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpuFabricInfoV(device, gpuFabricInfo); +} + +static inline nvmlReturn_t dispatch_nvmlSystemGetConfComputeCapabilities(nvmlConfComputeSystemCaps_t * capabilities) { + if (!nvml_dispatch.nvmlSystemGetConfComputeCapabilities) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemGetConfComputeCapabilities(capabilities); +} + +static inline nvmlReturn_t dispatch_nvmlSystemGetConfComputeState(nvmlConfComputeSystemState_t * state) { + if (!nvml_dispatch.nvmlSystemGetConfComputeState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemGetConfComputeState(state); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetConfComputeMemSizeInfo(nvmlDevice_t device, nvmlConfComputeMemSizeInfo_t * memInfo) { + if (!nvml_dispatch.nvmlDeviceGetConfComputeMemSizeInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetConfComputeMemSizeInfo(device, memInfo); +} + +static inline nvmlReturn_t dispatch_nvmlSystemGetConfComputeGpusReadyState(unsigned int * isAcceptingWork) { + if (!nvml_dispatch.nvmlSystemGetConfComputeGpusReadyState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemGetConfComputeGpusReadyState(isAcceptingWork); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetConfComputeProtectedMemoryUsage(nvmlDevice_t device, nvmlMemory_t * memory) { + if (!nvml_dispatch.nvmlDeviceGetConfComputeProtectedMemoryUsage) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetConfComputeProtectedMemoryUsage(device, memory); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetConfComputeGpuCertificate(nvmlDevice_t device, nvmlConfComputeGpuCertificate_t * gpuCert) { + if (!nvml_dispatch.nvmlDeviceGetConfComputeGpuCertificate) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetConfComputeGpuCertificate(device, gpuCert); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetConfComputeGpuAttestationReport(nvmlDevice_t device, nvmlConfComputeGpuAttestationReport_t * gpuAtstReport) { + if (!nvml_dispatch.nvmlDeviceGetConfComputeGpuAttestationReport) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetConfComputeGpuAttestationReport(device, gpuAtstReport); +} + +static inline nvmlReturn_t dispatch_nvmlSystemGetConfComputeKeyRotationThresholdInfo(nvmlConfComputeGetKeyRotationThresholdInfo_t * pKeyRotationThrInfo) { + if (!nvml_dispatch.nvmlSystemGetConfComputeKeyRotationThresholdInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemGetConfComputeKeyRotationThresholdInfo(pKeyRotationThrInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetConfComputeUnprotectedMemSize(nvmlDevice_t device, unsigned long long sizeKiB) { + if (!nvml_dispatch.nvmlDeviceSetConfComputeUnprotectedMemSize) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetConfComputeUnprotectedMemSize(device, sizeKiB); +} + +static inline nvmlReturn_t dispatch_nvmlSystemSetConfComputeGpusReadyState(unsigned int isAcceptingWork) { + if (!nvml_dispatch.nvmlSystemSetConfComputeGpusReadyState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemSetConfComputeGpusReadyState(isAcceptingWork); +} + +static inline nvmlReturn_t dispatch_nvmlSystemSetConfComputeKeyRotationThresholdInfo(nvmlConfComputeSetKeyRotationThresholdInfo_t * pKeyRotationThrInfo) { + if (!nvml_dispatch.nvmlSystemSetConfComputeKeyRotationThresholdInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemSetConfComputeKeyRotationThresholdInfo(pKeyRotationThrInfo); +} + +static inline nvmlReturn_t dispatch_nvmlSystemGetConfComputeSettings(nvmlSystemConfComputeSettings_t * settings) { + if (!nvml_dispatch.nvmlSystemGetConfComputeSettings) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemGetConfComputeSettings(settings); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGspFirmwareVersion(nvmlDevice_t device, char * version) { + if (!nvml_dispatch.nvmlDeviceGetGspFirmwareVersion) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGspFirmwareVersion(device, version); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGspFirmwareMode(nvmlDevice_t device, unsigned int * isEnabled, unsigned int * defaultMode) { + if (!nvml_dispatch.nvmlDeviceGetGspFirmwareMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGspFirmwareMode(device, isEnabled, defaultMode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetSramEccErrorStatus(nvmlDevice_t device, nvmlEccSramErrorStatus_t * status) { + if (!nvml_dispatch.nvmlDeviceGetSramEccErrorStatus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetSramEccErrorStatus(device, status); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetPowerManagementLimit_v2(nvmlDevice_t device, nvmlPowerValue_v2_t * powerValue) { + if (!nvml_dispatch.nvmlDeviceSetPowerManagementLimit_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetPowerManagementLimit_v2(device, powerValue); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetAccountingMode(nvmlDevice_t device, nvmlEnableState_t * mode) { + if (!nvml_dispatch.nvmlDeviceGetAccountingMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetAccountingMode(device, mode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetAccountingStats(nvmlDevice_t device, unsigned int pid, nvmlAccountingStats_t * stats) { + if (!nvml_dispatch.nvmlDeviceGetAccountingStats) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetAccountingStats(device, pid, stats); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetAccountingPids(nvmlDevice_t device, unsigned int * count, unsigned int * pids) { + if (!nvml_dispatch.nvmlDeviceGetAccountingPids) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetAccountingPids(device, count, pids); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetAccountingBufferSize(nvmlDevice_t device, unsigned int * bufferSize) { + if (!nvml_dispatch.nvmlDeviceGetAccountingBufferSize) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetAccountingBufferSize(device, bufferSize); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetRetiredPages(nvmlDevice_t device, nvmlPageRetirementCause_t cause, unsigned int * pageCount, unsigned long long * addresses) { + if (!nvml_dispatch.nvmlDeviceGetRetiredPages) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetRetiredPages(device, cause, pageCount, addresses); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetRetiredPages_v2(nvmlDevice_t device, nvmlPageRetirementCause_t cause, unsigned int * pageCount, unsigned long long * addresses, unsigned long long * timestamps) { + if (!nvml_dispatch.nvmlDeviceGetRetiredPages_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetRetiredPages_v2(device, cause, pageCount, addresses, timestamps); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetRetiredPagesPendingStatus(nvmlDevice_t device, nvmlEnableState_t * isPending) { + if (!nvml_dispatch.nvmlDeviceGetRetiredPagesPendingStatus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetRetiredPagesPendingStatus(device, isPending); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetRemappedRows(nvmlDevice_t device, unsigned int * corrRows, unsigned int * uncRows, unsigned int * isPending, unsigned int * failureOccurred) { + if (!nvml_dispatch.nvmlDeviceGetRemappedRows) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetRemappedRows(device, corrRows, uncRows, isPending, failureOccurred); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetRowRemapperHistogram(nvmlDevice_t device, nvmlRowRemapperHistogramValues_t * values) { + if (!nvml_dispatch.nvmlDeviceGetRowRemapperHistogram) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetRowRemapperHistogram(device, values); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetArchitecture(nvmlDevice_t device, nvmlDeviceArchitecture_t * arch) { + if (!nvml_dispatch.nvmlDeviceGetArchitecture) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetArchitecture(device, arch); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetClkMonStatus(nvmlDevice_t device, nvmlClkMonStatus_t * status) { + if (!nvml_dispatch.nvmlDeviceGetClkMonStatus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetClkMonStatus(device, status); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetProcessUtilization(nvmlDevice_t device, nvmlProcessUtilizationSample_t * utilization, unsigned int * processSamplesCount, unsigned long long lastSeenTimeStamp) { + if (!nvml_dispatch.nvmlDeviceGetProcessUtilization) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetProcessUtilization(device, utilization, processSamplesCount, lastSeenTimeStamp); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetProcessesUtilizationInfo(nvmlDevice_t device, nvmlProcessesUtilizationInfo_t * procesesUtilInfo) { + if (!nvml_dispatch.nvmlDeviceGetProcessesUtilizationInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetProcessesUtilizationInfo(device, procesesUtilInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPlatformInfo(nvmlDevice_t device, nvmlPlatformInfo_t * platformInfo) { + if (!nvml_dispatch.nvmlDeviceGetPlatformInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPlatformInfo(device, platformInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPdi(nvmlDevice_t device, nvmlPdi_t * pdi) { + if (!nvml_dispatch.nvmlDeviceGetPdi) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPdi(device, pdi); +} + +static inline nvmlReturn_t dispatch_nvmlUnitSetLedState(nvmlUnit_t unit, nvmlLedColor_t color) { + if (!nvml_dispatch.nvmlUnitSetLedState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlUnitSetLedState(unit, color); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetPersistenceMode(nvmlDevice_t device, nvmlEnableState_t mode) { + if (!nvml_dispatch.nvmlDeviceSetPersistenceMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetPersistenceMode(device, mode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetComputeMode(nvmlDevice_t device, nvmlComputeMode_t mode) { + if (!nvml_dispatch.nvmlDeviceSetComputeMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetComputeMode(device, mode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetEccMode(nvmlDevice_t device, nvmlEnableState_t ecc) { + if (!nvml_dispatch.nvmlDeviceSetEccMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetEccMode(device, ecc); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceClearEccErrorCounts(nvmlDevice_t device, nvmlEccCounterType_t counterType) { + if (!nvml_dispatch.nvmlDeviceClearEccErrorCounts) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceClearEccErrorCounts(device, counterType); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetDriverModel(nvmlDevice_t device, nvmlDriverModel_t driverModel, unsigned int flags) { + if (!nvml_dispatch.nvmlDeviceSetDriverModel) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetDriverModel(device, driverModel, flags); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetGpuLockedClocks(nvmlDevice_t device, unsigned int minGpuClockMHz, unsigned int maxGpuClockMHz) { + if (!nvml_dispatch.nvmlDeviceSetGpuLockedClocks) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetGpuLockedClocks(device, minGpuClockMHz, maxGpuClockMHz); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceResetGpuLockedClocks(nvmlDevice_t device) { + if (!nvml_dispatch.nvmlDeviceResetGpuLockedClocks) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceResetGpuLockedClocks(device); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetMemoryLockedClocks(nvmlDevice_t device, unsigned int minMemClockMHz, unsigned int maxMemClockMHz) { + if (!nvml_dispatch.nvmlDeviceSetMemoryLockedClocks) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetMemoryLockedClocks(device, minMemClockMHz, maxMemClockMHz); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceResetMemoryLockedClocks(nvmlDevice_t device) { + if (!nvml_dispatch.nvmlDeviceResetMemoryLockedClocks) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceResetMemoryLockedClocks(device); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetApplicationsClocks(nvmlDevice_t device, unsigned int memClockMHz, unsigned int graphicsClockMHz) { + if (!nvml_dispatch.nvmlDeviceSetApplicationsClocks) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetApplicationsClocks(device, memClockMHz, graphicsClockMHz); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceResetApplicationsClocks(nvmlDevice_t device) { + if (!nvml_dispatch.nvmlDeviceResetApplicationsClocks) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceResetApplicationsClocks(device); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t enabled) { + if (!nvml_dispatch.nvmlDeviceSetAutoBoostedClocksEnabled) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetAutoBoostedClocksEnabled(device, enabled); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetDefaultAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t enabled, unsigned int flags) { + if (!nvml_dispatch.nvmlDeviceSetDefaultAutoBoostedClocksEnabled) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetDefaultAutoBoostedClocksEnabled(device, enabled, flags); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetDefaultFanSpeed_v2(nvmlDevice_t device, unsigned int fan) { + if (!nvml_dispatch.nvmlDeviceSetDefaultFanSpeed_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetDefaultFanSpeed_v2(device, fan); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetFanControlPolicy(nvmlDevice_t device, unsigned int fan, nvmlFanControlPolicy_t policy) { + if (!nvml_dispatch.nvmlDeviceSetFanControlPolicy) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetFanControlPolicy(device, fan, policy); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetTemperatureThreshold(nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, int * temp) { + if (!nvml_dispatch.nvmlDeviceSetTemperatureThreshold) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetTemperatureThreshold(device, thresholdType, temp); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetPowerManagementLimit(nvmlDevice_t device, unsigned int limit) { + if (!nvml_dispatch.nvmlDeviceSetPowerManagementLimit) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetPowerManagementLimit(device, limit); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetGpuOperationMode(nvmlDevice_t device, nvmlGpuOperationMode_t mode) { + if (!nvml_dispatch.nvmlDeviceSetGpuOperationMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetGpuOperationMode(device, mode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetAPIRestriction(nvmlDevice_t device, nvmlRestrictedAPI_t apiType, nvmlEnableState_t isRestricted) { + if (!nvml_dispatch.nvmlDeviceSetAPIRestriction) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetAPIRestriction(device, apiType, isRestricted); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetFanSpeed_v2(nvmlDevice_t device, unsigned int fan, unsigned int speed) { + if (!nvml_dispatch.nvmlDeviceSetFanSpeed_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetFanSpeed_v2(device, fan, speed); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetGpcClkVfOffset(nvmlDevice_t device, int offset) { + if (!nvml_dispatch.nvmlDeviceSetGpcClkVfOffset) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetGpcClkVfOffset(device, offset); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetMemClkVfOffset(nvmlDevice_t device, int offset) { + if (!nvml_dispatch.nvmlDeviceSetMemClkVfOffset) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetMemClkVfOffset(device, offset); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetAccountingMode(nvmlDevice_t device, nvmlEnableState_t mode) { + if (!nvml_dispatch.nvmlDeviceSetAccountingMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetAccountingMode(device, mode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceClearAccountingPids(nvmlDevice_t device) { + if (!nvml_dispatch.nvmlDeviceClearAccountingPids) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceClearAccountingPids(device); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNvLinkState(nvmlDevice_t device, unsigned int link, nvmlEnableState_t * isActive) { + if (!nvml_dispatch.nvmlDeviceGetNvLinkState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNvLinkState(device, link, isActive); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNvLinkVersion(nvmlDevice_t device, unsigned int link, unsigned int * version) { + if (!nvml_dispatch.nvmlDeviceGetNvLinkVersion) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNvLinkVersion(device, link, version); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNvLinkCapability(nvmlDevice_t device, unsigned int link, nvmlNvLinkCapability_t capability, unsigned int * capResult) { + if (!nvml_dispatch.nvmlDeviceGetNvLinkCapability) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNvLinkCapability(device, link, capability, capResult); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNvLinkRemotePciInfo_v2(nvmlDevice_t device, unsigned int link, nvmlPciInfo_t * pci) { + if (!nvml_dispatch.nvmlDeviceGetNvLinkRemotePciInfo_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNvLinkRemotePciInfo_v2(device, link, pci); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNvLinkErrorCounter(nvmlDevice_t device, unsigned int link, nvmlNvLinkErrorCounter_t counter, unsigned long long * counterValue) { + if (!nvml_dispatch.nvmlDeviceGetNvLinkErrorCounter) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNvLinkErrorCounter(device, link, counter, counterValue); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceResetNvLinkErrorCounters(nvmlDevice_t device, unsigned int link) { + if (!nvml_dispatch.nvmlDeviceResetNvLinkErrorCounters) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceResetNvLinkErrorCounters(device, link); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetNvLinkUtilizationControl(nvmlDevice_t device, unsigned int link, unsigned int counter, nvmlNvLinkUtilizationControl_t * control, unsigned int reset) { + if (!nvml_dispatch.nvmlDeviceSetNvLinkUtilizationControl) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetNvLinkUtilizationControl(device, link, counter, control, reset); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNvLinkUtilizationControl(nvmlDevice_t device, unsigned int link, unsigned int counter, nvmlNvLinkUtilizationControl_t * control) { + if (!nvml_dispatch.nvmlDeviceGetNvLinkUtilizationControl) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNvLinkUtilizationControl(device, link, counter, control); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNvLinkUtilizationCounter(nvmlDevice_t device, unsigned int link, unsigned int counter, unsigned long long * rxcounter, unsigned long long * txcounter) { + if (!nvml_dispatch.nvmlDeviceGetNvLinkUtilizationCounter) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNvLinkUtilizationCounter(device, link, counter, rxcounter, txcounter); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceFreezeNvLinkUtilizationCounter(nvmlDevice_t device, unsigned int link, unsigned int counter, nvmlEnableState_t freeze) { + if (!nvml_dispatch.nvmlDeviceFreezeNvLinkUtilizationCounter) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceFreezeNvLinkUtilizationCounter(device, link, counter, freeze); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceResetNvLinkUtilizationCounter(nvmlDevice_t device, unsigned int link, unsigned int counter) { + if (!nvml_dispatch.nvmlDeviceResetNvLinkUtilizationCounter) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceResetNvLinkUtilizationCounter(device, link, counter); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNvLinkRemoteDeviceType(nvmlDevice_t device, unsigned int link, nvmlIntNvLinkDeviceType_t * pNvLinkDeviceType) { + if (!nvml_dispatch.nvmlDeviceGetNvLinkRemoteDeviceType) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNvLinkRemoteDeviceType(device, link, pNvLinkDeviceType); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetNvLinkDeviceLowPowerThreshold(nvmlDevice_t device, nvmlNvLinkPowerThres_t * info) { + if (!nvml_dispatch.nvmlDeviceSetNvLinkDeviceLowPowerThreshold) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetNvLinkDeviceLowPowerThreshold(device, info); +} + +static inline nvmlReturn_t dispatch_nvmlSystemSetNvlinkBwMode(unsigned int nvlinkBwMode) { + if (!nvml_dispatch.nvmlSystemSetNvlinkBwMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemSetNvlinkBwMode(nvlinkBwMode); +} + +static inline nvmlReturn_t dispatch_nvmlSystemGetNvlinkBwMode(unsigned int * nvlinkBwMode) { + if (!nvml_dispatch.nvmlSystemGetNvlinkBwMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemGetNvlinkBwMode(nvlinkBwMode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNvlinkSupportedBwModes(nvmlDevice_t device, nvmlNvlinkSupportedBwModes_t * supportedBwMode) { + if (!nvml_dispatch.nvmlDeviceGetNvlinkSupportedBwModes) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNvlinkSupportedBwModes(device, supportedBwMode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNvlinkBwMode(nvmlDevice_t device, nvmlNvlinkGetBwMode_t * getBwMode) { + if (!nvml_dispatch.nvmlDeviceGetNvlinkBwMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNvlinkBwMode(device, getBwMode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetNvlinkBwMode(nvmlDevice_t device, nvmlNvlinkSetBwMode_t * setBwMode) { + if (!nvml_dispatch.nvmlDeviceSetNvlinkBwMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetNvlinkBwMode(device, setBwMode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNvLinkInfo(nvmlDevice_t device, nvmlNvLinkInfo_t * info) { + if (!nvml_dispatch.nvmlDeviceGetNvLinkInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNvLinkInfo(device, info); +} + +static inline nvmlReturn_t dispatch_nvmlEventSetCreate(nvmlEventSet_t * set) { + if (!nvml_dispatch.nvmlEventSetCreate) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlEventSetCreate(set); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceRegisterEvents(nvmlDevice_t device, unsigned long long eventTypes, nvmlEventSet_t set) { + if (!nvml_dispatch.nvmlDeviceRegisterEvents) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceRegisterEvents(device, eventTypes, set); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetSupportedEventTypes(nvmlDevice_t device, unsigned long long * eventTypes) { + if (!nvml_dispatch.nvmlDeviceGetSupportedEventTypes) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetSupportedEventTypes(device, eventTypes); +} + +static inline nvmlReturn_t dispatch_nvmlEventSetWait_v2(nvmlEventSet_t set, nvmlEventData_t * data, unsigned int timeoutms) { + if (!nvml_dispatch.nvmlEventSetWait_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlEventSetWait_v2(set, data, timeoutms); +} + +static inline nvmlReturn_t dispatch_nvmlEventSetFree(nvmlEventSet_t set) { + if (!nvml_dispatch.nvmlEventSetFree) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlEventSetFree(set); +} + +static inline nvmlReturn_t dispatch_nvmlSystemEventSetCreate(nvmlSystemEventSetCreateRequest_t * request) { + if (!nvml_dispatch.nvmlSystemEventSetCreate) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemEventSetCreate(request); +} + +static inline nvmlReturn_t dispatch_nvmlSystemEventSetFree(nvmlSystemEventSetFreeRequest_t * request) { + if (!nvml_dispatch.nvmlSystemEventSetFree) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemEventSetFree(request); +} + +static inline nvmlReturn_t dispatch_nvmlSystemRegisterEvents(nvmlSystemRegisterEventRequest_t * request) { + if (!nvml_dispatch.nvmlSystemRegisterEvents) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemRegisterEvents(request); +} + +static inline nvmlReturn_t dispatch_nvmlSystemEventSetWait(nvmlSystemEventSetWaitRequest_t * request) { + if (!nvml_dispatch.nvmlSystemEventSetWait) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSystemEventSetWait(request); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceModifyDrainState(nvmlPciInfo_t * pciInfo, nvmlEnableState_t newState) { + if (!nvml_dispatch.nvmlDeviceModifyDrainState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceModifyDrainState(pciInfo, newState); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceQueryDrainState(nvmlPciInfo_t * pciInfo, nvmlEnableState_t * currentState) { + if (!nvml_dispatch.nvmlDeviceQueryDrainState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceQueryDrainState(pciInfo, currentState); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceRemoveGpu_v2(nvmlPciInfo_t * pciInfo, nvmlDetachGpuState_t gpuState, nvmlPcieLinkState_t linkState) { + if (!nvml_dispatch.nvmlDeviceRemoveGpu_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceRemoveGpu_v2(pciInfo, gpuState, linkState); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceDiscoverGpus(nvmlPciInfo_t * pciInfo) { + if (!nvml_dispatch.nvmlDeviceDiscoverGpus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceDiscoverGpus(pciInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetFieldValues(nvmlDevice_t device, int valuesCount, nvmlFieldValue_t * values) { + if (!nvml_dispatch.nvmlDeviceGetFieldValues) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetFieldValues(device, valuesCount, values); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceClearFieldValues(nvmlDevice_t device, int valuesCount, nvmlFieldValue_t * values) { + if (!nvml_dispatch.nvmlDeviceClearFieldValues) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceClearFieldValues(device, valuesCount, values); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetVirtualizationMode(nvmlDevice_t device, nvmlGpuVirtualizationMode_t * pVirtualMode) { + if (!nvml_dispatch.nvmlDeviceGetVirtualizationMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetVirtualizationMode(device, pVirtualMode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetHostVgpuMode(nvmlDevice_t device, nvmlHostVgpuMode_t * pHostVgpuMode) { + if (!nvml_dispatch.nvmlDeviceGetHostVgpuMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetHostVgpuMode(device, pHostVgpuMode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetVirtualizationMode(nvmlDevice_t device, nvmlGpuVirtualizationMode_t virtualMode) { + if (!nvml_dispatch.nvmlDeviceSetVirtualizationMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetVirtualizationMode(device, virtualMode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetVgpuHeterogeneousMode(nvmlDevice_t device, nvmlVgpuHeterogeneousMode_t * pHeterogeneousMode) { + if (!nvml_dispatch.nvmlDeviceGetVgpuHeterogeneousMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetVgpuHeterogeneousMode(device, pHeterogeneousMode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetVgpuHeterogeneousMode(nvmlDevice_t device, const nvmlVgpuHeterogeneousMode_t * pHeterogeneousMode) { + if (!nvml_dispatch.nvmlDeviceSetVgpuHeterogeneousMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetVgpuHeterogeneousMode(device, pHeterogeneousMode); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetPlacementId(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuPlacementId_t * pPlacement) { + if (!nvml_dispatch.nvmlVgpuInstanceGetPlacementId) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetPlacementId(vgpuInstance, pPlacement); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetVgpuTypeSupportedPlacements(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuPlacementList_t * pPlacementList) { + if (!nvml_dispatch.nvmlDeviceGetVgpuTypeSupportedPlacements) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetVgpuTypeSupportedPlacements(device, vgpuTypeId, pPlacementList); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetVgpuTypeCreatablePlacements(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuPlacementList_t * pPlacementList) { + if (!nvml_dispatch.nvmlDeviceGetVgpuTypeCreatablePlacements) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetVgpuTypeCreatablePlacements(device, vgpuTypeId, pPlacementList); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetGspHeapSize(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long * gspHeapSize) { + if (!nvml_dispatch.nvmlVgpuTypeGetGspHeapSize) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetGspHeapSize(vgpuTypeId, gspHeapSize); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetFbReservation(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long * fbReservation) { + if (!nvml_dispatch.nvmlVgpuTypeGetFbReservation) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetFbReservation(vgpuTypeId, fbReservation); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetRuntimeStateSize(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuRuntimeState_t * pState) { + if (!nvml_dispatch.nvmlVgpuInstanceGetRuntimeStateSize) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetRuntimeStateSize(vgpuInstance, pState); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetVgpuCapabilities(nvmlDevice_t device, nvmlDeviceVgpuCapability_t capability, nvmlEnableState_t state) { + if (!nvml_dispatch.nvmlDeviceSetVgpuCapabilities) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetVgpuCapabilities(device, capability, state); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGridLicensableFeatures_v4(nvmlDevice_t device, nvmlGridLicensableFeatures_t * pGridLicensableFeatures) { + if (!nvml_dispatch.nvmlDeviceGetGridLicensableFeatures_v4) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGridLicensableFeatures_v4(device, pGridLicensableFeatures); +} + +static inline nvmlReturn_t dispatch_nvmlGetVgpuDriverCapabilities(nvmlVgpuDriverCapability_t capability, unsigned int * capResult) { + if (!nvml_dispatch.nvmlGetVgpuDriverCapabilities) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGetVgpuDriverCapabilities(capability, capResult); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetVgpuCapabilities(nvmlDevice_t device, nvmlDeviceVgpuCapability_t capability, unsigned int * capResult) { + if (!nvml_dispatch.nvmlDeviceGetVgpuCapabilities) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetVgpuCapabilities(device, capability, capResult); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetSupportedVgpus(nvmlDevice_t device, unsigned int * vgpuCount, nvmlVgpuTypeId_t * vgpuTypeIds) { + if (!nvml_dispatch.nvmlDeviceGetSupportedVgpus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetSupportedVgpus(device, vgpuCount, vgpuTypeIds); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetCreatableVgpus(nvmlDevice_t device, unsigned int * vgpuCount, nvmlVgpuTypeId_t * vgpuTypeIds) { + if (!nvml_dispatch.nvmlDeviceGetCreatableVgpus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetCreatableVgpus(device, vgpuCount, vgpuTypeIds); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetClass(nvmlVgpuTypeId_t vgpuTypeId, char * vgpuTypeClass, unsigned int * size) { + if (!nvml_dispatch.nvmlVgpuTypeGetClass) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetClass(vgpuTypeId, vgpuTypeClass, size); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetName(nvmlVgpuTypeId_t vgpuTypeId, char * vgpuTypeName, unsigned int * size) { + if (!nvml_dispatch.nvmlVgpuTypeGetName) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetName(vgpuTypeId, vgpuTypeName, size); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetGpuInstanceProfileId(nvmlVgpuTypeId_t vgpuTypeId, unsigned int * gpuInstanceProfileId) { + if (!nvml_dispatch.nvmlVgpuTypeGetGpuInstanceProfileId) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetGpuInstanceProfileId(vgpuTypeId, gpuInstanceProfileId); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetDeviceID(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long * deviceID, unsigned long long * subsystemID) { + if (!nvml_dispatch.nvmlVgpuTypeGetDeviceID) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetDeviceID(vgpuTypeId, deviceID, subsystemID); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetFramebufferSize(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long * fbSize) { + if (!nvml_dispatch.nvmlVgpuTypeGetFramebufferSize) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetFramebufferSize(vgpuTypeId, fbSize); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetNumDisplayHeads(nvmlVgpuTypeId_t vgpuTypeId, unsigned int * numDisplayHeads) { + if (!nvml_dispatch.nvmlVgpuTypeGetNumDisplayHeads) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetNumDisplayHeads(vgpuTypeId, numDisplayHeads); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetResolution(nvmlVgpuTypeId_t vgpuTypeId, unsigned int displayIndex, unsigned int * xdim, unsigned int * ydim) { + if (!nvml_dispatch.nvmlVgpuTypeGetResolution) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetResolution(vgpuTypeId, displayIndex, xdim, ydim); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetLicense(nvmlVgpuTypeId_t vgpuTypeId, char * vgpuTypeLicenseString, unsigned int size) { + if (!nvml_dispatch.nvmlVgpuTypeGetLicense) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetLicense(vgpuTypeId, vgpuTypeLicenseString, size); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetFrameRateLimit(nvmlVgpuTypeId_t vgpuTypeId, unsigned int * frameRateLimit) { + if (!nvml_dispatch.nvmlVgpuTypeGetFrameRateLimit) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetFrameRateLimit(vgpuTypeId, frameRateLimit); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetMaxInstances(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, unsigned int * vgpuInstanceCount) { + if (!nvml_dispatch.nvmlVgpuTypeGetMaxInstances) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetMaxInstances(device, vgpuTypeId, vgpuInstanceCount); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetMaxInstancesPerVm(nvmlVgpuTypeId_t vgpuTypeId, unsigned int * vgpuInstanceCountPerVm) { + if (!nvml_dispatch.nvmlVgpuTypeGetMaxInstancesPerVm) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetMaxInstancesPerVm(vgpuTypeId, vgpuInstanceCountPerVm); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetBAR1Info(nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuTypeBar1Info_t * bar1Info) { + if (!nvml_dispatch.nvmlVgpuTypeGetBAR1Info) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetBAR1Info(vgpuTypeId, bar1Info); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetActiveVgpus(nvmlDevice_t device, unsigned int * vgpuCount, nvmlVgpuInstance_t * vgpuInstances) { + if (!nvml_dispatch.nvmlDeviceGetActiveVgpus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetActiveVgpus(device, vgpuCount, vgpuInstances); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetVmID(nvmlVgpuInstance_t vgpuInstance, char * vmId, unsigned int size, nvmlVgpuVmIdType_t * vmIdType) { + if (!nvml_dispatch.nvmlVgpuInstanceGetVmID) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetVmID(vgpuInstance, vmId, size, vmIdType); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetUUID(nvmlVgpuInstance_t vgpuInstance, char * uuid, unsigned int size) { + if (!nvml_dispatch.nvmlVgpuInstanceGetUUID) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetUUID(vgpuInstance, uuid, size); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetVmDriverVersion(nvmlVgpuInstance_t vgpuInstance, char* version, unsigned int length) { + if (!nvml_dispatch.nvmlVgpuInstanceGetVmDriverVersion) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetVmDriverVersion(vgpuInstance, version, length); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetFbUsage(nvmlVgpuInstance_t vgpuInstance, unsigned long long * fbUsage) { + if (!nvml_dispatch.nvmlVgpuInstanceGetFbUsage) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetFbUsage(vgpuInstance, fbUsage); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetLicenseStatus(nvmlVgpuInstance_t vgpuInstance, unsigned int * licensed) { + if (!nvml_dispatch.nvmlVgpuInstanceGetLicenseStatus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetLicenseStatus(vgpuInstance, licensed); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetType(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuTypeId_t * vgpuTypeId) { + if (!nvml_dispatch.nvmlVgpuInstanceGetType) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetType(vgpuInstance, vgpuTypeId); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetFrameRateLimit(nvmlVgpuInstance_t vgpuInstance, unsigned int * frameRateLimit) { + if (!nvml_dispatch.nvmlVgpuInstanceGetFrameRateLimit) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetFrameRateLimit(vgpuInstance, frameRateLimit); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetEccMode(nvmlVgpuInstance_t vgpuInstance, nvmlEnableState_t * eccMode) { + if (!nvml_dispatch.nvmlVgpuInstanceGetEccMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetEccMode(vgpuInstance, eccMode); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetEncoderCapacity(nvmlVgpuInstance_t vgpuInstance, unsigned int * encoderCapacity) { + if (!nvml_dispatch.nvmlVgpuInstanceGetEncoderCapacity) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetEncoderCapacity(vgpuInstance, encoderCapacity); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceSetEncoderCapacity(nvmlVgpuInstance_t vgpuInstance, unsigned int encoderCapacity) { + if (!nvml_dispatch.nvmlVgpuInstanceSetEncoderCapacity) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceSetEncoderCapacity(vgpuInstance, encoderCapacity); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetEncoderStats(nvmlVgpuInstance_t vgpuInstance, unsigned int * sessionCount, unsigned int * averageFps, unsigned int * averageLatency) { + if (!nvml_dispatch.nvmlVgpuInstanceGetEncoderStats) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetEncoderStats(vgpuInstance, sessionCount, averageFps, averageLatency); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetEncoderSessions(nvmlVgpuInstance_t vgpuInstance, unsigned int * sessionCount, nvmlEncoderSessionInfo_t * sessionInfo) { + if (!nvml_dispatch.nvmlVgpuInstanceGetEncoderSessions) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetEncoderSessions(vgpuInstance, sessionCount, sessionInfo); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetFBCStats(nvmlVgpuInstance_t vgpuInstance, nvmlFBCStats_t * fbcStats) { + if (!nvml_dispatch.nvmlVgpuInstanceGetFBCStats) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetFBCStats(vgpuInstance, fbcStats); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetFBCSessions(nvmlVgpuInstance_t vgpuInstance, unsigned int * sessionCount, nvmlFBCSessionInfo_t * sessionInfo) { + if (!nvml_dispatch.nvmlVgpuInstanceGetFBCSessions) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetFBCSessions(vgpuInstance, sessionCount, sessionInfo); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetGpuInstanceId(nvmlVgpuInstance_t vgpuInstance, unsigned int * gpuInstanceId) { + if (!nvml_dispatch.nvmlVgpuInstanceGetGpuInstanceId) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetGpuInstanceId(vgpuInstance, gpuInstanceId); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetGpuPciId(nvmlVgpuInstance_t vgpuInstance, char * vgpuPciId, unsigned int * length) { + if (!nvml_dispatch.nvmlVgpuInstanceGetGpuPciId) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetGpuPciId(vgpuInstance, vgpuPciId, length); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetCapabilities(nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuCapability_t capability, unsigned int * capResult) { + if (!nvml_dispatch.nvmlVgpuTypeGetCapabilities) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetCapabilities(vgpuTypeId, capability, capResult); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetMdevUUID(nvmlVgpuInstance_t vgpuInstance, char * mdevUuid, unsigned int size) { + if (!nvml_dispatch.nvmlVgpuInstanceGetMdevUUID) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetMdevUUID(vgpuInstance, mdevUuid, size); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceGetCreatableVgpus(nvmlGpuInstance_t gpuInstance, nvmlVgpuTypeIdInfo_t * pVgpus) { + if (!nvml_dispatch.nvmlGpuInstanceGetCreatableVgpus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceGetCreatableVgpus(gpuInstance, pVgpus); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuTypeGetMaxInstancesPerGpuInstance(nvmlVgpuTypeMaxInstance_t * pMaxInstance) { + if (!nvml_dispatch.nvmlVgpuTypeGetMaxInstancesPerGpuInstance) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuTypeGetMaxInstancesPerGpuInstance(pMaxInstance); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceGetActiveVgpus(nvmlGpuInstance_t gpuInstance, nvmlActiveVgpuInstanceInfo_t * pVgpuInstanceInfo) { + if (!nvml_dispatch.nvmlGpuInstanceGetActiveVgpus) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceGetActiveVgpus(gpuInstance, pVgpuInstanceInfo); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceSetVgpuSchedulerState(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerState_t * pScheduler) { + if (!nvml_dispatch.nvmlGpuInstanceSetVgpuSchedulerState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceSetVgpuSchedulerState(gpuInstance, pScheduler); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceGetVgpuSchedulerState(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerStateInfo_t * pSchedulerStateInfo) { + if (!nvml_dispatch.nvmlGpuInstanceGetVgpuSchedulerState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceGetVgpuSchedulerState(gpuInstance, pSchedulerStateInfo); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceGetVgpuSchedulerLog(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerLogInfo_t * pSchedulerLogInfo) { + if (!nvml_dispatch.nvmlGpuInstanceGetVgpuSchedulerLog) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceGetVgpuSchedulerLog(gpuInstance, pSchedulerLogInfo); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceGetVgpuTypeCreatablePlacements(nvmlGpuInstance_t gpuInstance, nvmlVgpuCreatablePlacementInfo_t * pCreatablePlacementInfo) { + if (!nvml_dispatch.nvmlGpuInstanceGetVgpuTypeCreatablePlacements) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceGetVgpuTypeCreatablePlacements(gpuInstance, pCreatablePlacementInfo); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceGetVgpuHeterogeneousMode(nvmlGpuInstance_t gpuInstance, nvmlVgpuHeterogeneousMode_t * pHeterogeneousMode) { + if (!nvml_dispatch.nvmlGpuInstanceGetVgpuHeterogeneousMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceGetVgpuHeterogeneousMode(gpuInstance, pHeterogeneousMode); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceSetVgpuHeterogeneousMode(nvmlGpuInstance_t gpuInstance, const nvmlVgpuHeterogeneousMode_t * pHeterogeneousMode) { + if (!nvml_dispatch.nvmlGpuInstanceSetVgpuHeterogeneousMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceSetVgpuHeterogeneousMode(gpuInstance, pHeterogeneousMode); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetMetadata(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuMetadata_t * vgpuMetadata, unsigned int * bufferSize) { + if (!nvml_dispatch.nvmlVgpuInstanceGetMetadata) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetMetadata(vgpuInstance, vgpuMetadata, bufferSize); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetVgpuMetadata(nvmlDevice_t device, nvmlVgpuPgpuMetadata_t * pgpuMetadata, unsigned int * bufferSize) { + if (!nvml_dispatch.nvmlDeviceGetVgpuMetadata) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetVgpuMetadata(device, pgpuMetadata, bufferSize); +} + +static inline nvmlReturn_t dispatch_nvmlGetVgpuCompatibility(nvmlVgpuMetadata_t * vgpuMetadata, nvmlVgpuPgpuMetadata_t * pgpuMetadata, nvmlVgpuPgpuCompatibility_t * compatibilityInfo) { + if (!nvml_dispatch.nvmlGetVgpuCompatibility) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGetVgpuCompatibility(vgpuMetadata, pgpuMetadata, compatibilityInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPgpuMetadataString(nvmlDevice_t device, char * pgpuMetadata, unsigned int * bufferSize) { + if (!nvml_dispatch.nvmlDeviceGetPgpuMetadataString) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPgpuMetadataString(device, pgpuMetadata, bufferSize); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetVgpuSchedulerLog(nvmlDevice_t device, nvmlVgpuSchedulerLog_t * pSchedulerLog) { + if (!nvml_dispatch.nvmlDeviceGetVgpuSchedulerLog) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetVgpuSchedulerLog(device, pSchedulerLog); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetVgpuSchedulerState(nvmlDevice_t device, nvmlVgpuSchedulerGetState_t * pSchedulerState) { + if (!nvml_dispatch.nvmlDeviceGetVgpuSchedulerState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetVgpuSchedulerState(device, pSchedulerState); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetVgpuSchedulerCapabilities(nvmlDevice_t device, nvmlVgpuSchedulerCapabilities_t * pCapabilities) { + if (!nvml_dispatch.nvmlDeviceGetVgpuSchedulerCapabilities) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetVgpuSchedulerCapabilities(device, pCapabilities); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetVgpuSchedulerState(nvmlDevice_t device, nvmlVgpuSchedulerSetState_t * pSchedulerState) { + if (!nvml_dispatch.nvmlDeviceSetVgpuSchedulerState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetVgpuSchedulerState(device, pSchedulerState); +} + +static inline nvmlReturn_t dispatch_nvmlGetVgpuVersion(nvmlVgpuVersion_t * supported, nvmlVgpuVersion_t * current) { + if (!nvml_dispatch.nvmlGetVgpuVersion) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGetVgpuVersion(supported, current); +} + +static inline nvmlReturn_t dispatch_nvmlSetVgpuVersion(nvmlVgpuVersion_t * vgpuVersion) { + if (!nvml_dispatch.nvmlSetVgpuVersion) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlSetVgpuVersion(vgpuVersion); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetVgpuUtilization(nvmlDevice_t device, unsigned long long lastSeenTimeStamp, nvmlValueType_t * sampleValType, unsigned int * vgpuInstanceSamplesCount, nvmlVgpuInstanceUtilizationSample_t * utilizationSamples) { + if (!nvml_dispatch.nvmlDeviceGetVgpuUtilization) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetVgpuUtilization(device, lastSeenTimeStamp, sampleValType, vgpuInstanceSamplesCount, utilizationSamples); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetVgpuInstancesUtilizationInfo(nvmlDevice_t device, nvmlVgpuInstancesUtilizationInfo_t * vgpuUtilInfo) { + if (!nvml_dispatch.nvmlDeviceGetVgpuInstancesUtilizationInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetVgpuInstancesUtilizationInfo(device, vgpuUtilInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetVgpuProcessUtilization(nvmlDevice_t device, unsigned long long lastSeenTimeStamp, unsigned int * vgpuProcessSamplesCount, nvmlVgpuProcessUtilizationSample_t * utilizationSamples) { + if (!nvml_dispatch.nvmlDeviceGetVgpuProcessUtilization) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetVgpuProcessUtilization(device, lastSeenTimeStamp, vgpuProcessSamplesCount, utilizationSamples); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetVgpuProcessesUtilizationInfo(nvmlDevice_t device, nvmlVgpuProcessesUtilizationInfo_t * vgpuProcUtilInfo) { + if (!nvml_dispatch.nvmlDeviceGetVgpuProcessesUtilizationInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetVgpuProcessesUtilizationInfo(device, vgpuProcUtilInfo); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetAccountingMode(nvmlVgpuInstance_t vgpuInstance, nvmlEnableState_t * mode) { + if (!nvml_dispatch.nvmlVgpuInstanceGetAccountingMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetAccountingMode(vgpuInstance, mode); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetAccountingPids(nvmlVgpuInstance_t vgpuInstance, unsigned int * count, unsigned int * pids) { + if (!nvml_dispatch.nvmlVgpuInstanceGetAccountingPids) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetAccountingPids(vgpuInstance, count, pids); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetAccountingStats(nvmlVgpuInstance_t vgpuInstance, unsigned int pid, nvmlAccountingStats_t * stats) { + if (!nvml_dispatch.nvmlVgpuInstanceGetAccountingStats) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetAccountingStats(vgpuInstance, pid, stats); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceClearAccountingPids(nvmlVgpuInstance_t vgpuInstance) { + if (!nvml_dispatch.nvmlVgpuInstanceClearAccountingPids) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceClearAccountingPids(vgpuInstance); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetLicenseInfo_v2(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuLicenseInfo_t * licenseInfo) { + if (!nvml_dispatch.nvmlVgpuInstanceGetLicenseInfo_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetLicenseInfo_v2(vgpuInstance, licenseInfo); +} + +static inline nvmlReturn_t dispatch_nvmlGetExcludedDeviceCount(unsigned int * deviceCount) { + if (!nvml_dispatch.nvmlGetExcludedDeviceCount) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGetExcludedDeviceCount(deviceCount); +} + +static inline nvmlReturn_t dispatch_nvmlGetExcludedDeviceInfoByIndex(unsigned int index, nvmlExcludedDeviceInfo_t * info) { + if (!nvml_dispatch.nvmlGetExcludedDeviceInfoByIndex) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGetExcludedDeviceInfoByIndex(index, info); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceReadWritePRM_v1(nvmlDevice_t device, nvmlPRMTLV_v1_t * buffer) { + if (!nvml_dispatch.nvmlDeviceReadWritePRM_v1) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceReadWritePRM_v1(device, buffer); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceSetMigMode(nvmlDevice_t device, unsigned int mode, nvmlReturn_t * activationStatus) { + if (!nvml_dispatch.nvmlDeviceSetMigMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceSetMigMode(device, mode, activationStatus); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMigMode(nvmlDevice_t device, unsigned int * currentMode, unsigned int * pendingMode) { + if (!nvml_dispatch.nvmlDeviceGetMigMode) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMigMode(device, currentMode, pendingMode); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpuInstanceProfileInfo(nvmlDevice_t device, unsigned int profile, nvmlGpuInstanceProfileInfo_t * info) { + if (!nvml_dispatch.nvmlDeviceGetGpuInstanceProfileInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpuInstanceProfileInfo(device, profile, info); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpuInstanceProfileInfoV(nvmlDevice_t device, unsigned int profile, nvmlGpuInstanceProfileInfo_v2_t * info) { + if (!nvml_dispatch.nvmlDeviceGetGpuInstanceProfileInfoV) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpuInstanceProfileInfoV(device, profile, info); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpuInstanceProfileInfoByIdV(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstanceProfileInfo_v2_t * info) { + if (!nvml_dispatch.nvmlDeviceGetGpuInstanceProfileInfoByIdV) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpuInstanceProfileInfoByIdV(device, profileId, info); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpuInstancePossiblePlacements_v2(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstancePlacement_t * placements, unsigned int * count) { + if (!nvml_dispatch.nvmlDeviceGetGpuInstancePossiblePlacements_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpuInstancePossiblePlacements_v2(device, profileId, placements, count); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpuInstanceRemainingCapacity(nvmlDevice_t device, unsigned int profileId, unsigned int * count) { + if (!nvml_dispatch.nvmlDeviceGetGpuInstanceRemainingCapacity) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpuInstanceRemainingCapacity(device, profileId, count); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceCreateGpuInstance(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstance_t * gpuInstance) { + if (!nvml_dispatch.nvmlDeviceCreateGpuInstance) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceCreateGpuInstance(device, profileId, gpuInstance); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceCreateGpuInstanceWithPlacement(nvmlDevice_t device, unsigned int profileId, const nvmlGpuInstancePlacement_t * placement, nvmlGpuInstance_t * gpuInstance) { + if (!nvml_dispatch.nvmlDeviceCreateGpuInstanceWithPlacement) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceCreateGpuInstanceWithPlacement(device, profileId, placement, gpuInstance); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceDestroy(nvmlGpuInstance_t gpuInstance) { + if (!nvml_dispatch.nvmlGpuInstanceDestroy) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceDestroy(gpuInstance); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpuInstances(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstance_t * gpuInstances, unsigned int * count) { + if (!nvml_dispatch.nvmlDeviceGetGpuInstances) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpuInstances(device, profileId, gpuInstances, count); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpuInstanceById(nvmlDevice_t device, unsigned int id, nvmlGpuInstance_t * gpuInstance) { + if (!nvml_dispatch.nvmlDeviceGetGpuInstanceById) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpuInstanceById(device, id, gpuInstance); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceGetInfo(nvmlGpuInstance_t gpuInstance, nvmlGpuInstanceInfo_t * info) { + if (!nvml_dispatch.nvmlGpuInstanceGetInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceGetInfo(gpuInstance, info); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceGetComputeInstanceProfileInfo(nvmlGpuInstance_t gpuInstance, unsigned int profile, unsigned int engProfile, nvmlComputeInstanceProfileInfo_t * info) { + if (!nvml_dispatch.nvmlGpuInstanceGetComputeInstanceProfileInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceGetComputeInstanceProfileInfo(gpuInstance, profile, engProfile, info); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceGetComputeInstanceProfileInfoV(nvmlGpuInstance_t gpuInstance, unsigned int profile, unsigned int engProfile, nvmlComputeInstanceProfileInfo_v2_t * info) { + if (!nvml_dispatch.nvmlGpuInstanceGetComputeInstanceProfileInfoV) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceGetComputeInstanceProfileInfoV(gpuInstance, profile, engProfile, info); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceGetComputeInstanceRemainingCapacity(nvmlGpuInstance_t gpuInstance, unsigned int profileId, unsigned int * count) { + if (!nvml_dispatch.nvmlGpuInstanceGetComputeInstanceRemainingCapacity) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceGetComputeInstanceRemainingCapacity(gpuInstance, profileId, count); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceGetComputeInstancePossiblePlacements(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstancePlacement_t * placements, unsigned int * count) { + if (!nvml_dispatch.nvmlGpuInstanceGetComputeInstancePossiblePlacements) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceGetComputeInstancePossiblePlacements(gpuInstance, profileId, placements, count); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceCreateComputeInstance(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstance_t * computeInstance) { + if (!nvml_dispatch.nvmlGpuInstanceCreateComputeInstance) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceCreateComputeInstance(gpuInstance, profileId, computeInstance); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceCreateComputeInstanceWithPlacement(nvmlGpuInstance_t gpuInstance, unsigned int profileId, const nvmlComputeInstancePlacement_t * placement, nvmlComputeInstance_t * computeInstance) { + if (!nvml_dispatch.nvmlGpuInstanceCreateComputeInstanceWithPlacement) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceCreateComputeInstanceWithPlacement(gpuInstance, profileId, placement, computeInstance); +} + +static inline nvmlReturn_t dispatch_nvmlComputeInstanceDestroy(nvmlComputeInstance_t computeInstance) { + if (!nvml_dispatch.nvmlComputeInstanceDestroy) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlComputeInstanceDestroy(computeInstance); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceGetComputeInstances(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstance_t * computeInstances, unsigned int * count) { + if (!nvml_dispatch.nvmlGpuInstanceGetComputeInstances) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceGetComputeInstances(gpuInstance, profileId, computeInstances, count); +} + +static inline nvmlReturn_t dispatch_nvmlGpuInstanceGetComputeInstanceById(nvmlGpuInstance_t gpuInstance, unsigned int id, nvmlComputeInstance_t * computeInstance) { + if (!nvml_dispatch.nvmlGpuInstanceGetComputeInstanceById) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpuInstanceGetComputeInstanceById(gpuInstance, id, computeInstance); +} + +static inline nvmlReturn_t dispatch_nvmlComputeInstanceGetInfo_v2(nvmlComputeInstance_t computeInstance, nvmlComputeInstanceInfo_t * info) { + if (!nvml_dispatch.nvmlComputeInstanceGetInfo_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlComputeInstanceGetInfo_v2(computeInstance, info); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceIsMigDeviceHandle(nvmlDevice_t device, unsigned int * isMigDevice) { + if (!nvml_dispatch.nvmlDeviceIsMigDeviceHandle) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceIsMigDeviceHandle(device, isMigDevice); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpuInstanceId(nvmlDevice_t device, unsigned int * id) { + if (!nvml_dispatch.nvmlDeviceGetGpuInstanceId) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpuInstanceId(device, id); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetComputeInstanceId(nvmlDevice_t device, unsigned int * id) { + if (!nvml_dispatch.nvmlDeviceGetComputeInstanceId) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetComputeInstanceId(device, id); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMaxMigDeviceCount(nvmlDevice_t device, unsigned int * count) { + if (!nvml_dispatch.nvmlDeviceGetMaxMigDeviceCount) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMaxMigDeviceCount(device, count); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMigDeviceHandleByIndex(nvmlDevice_t device, unsigned int index, nvmlDevice_t * migDevice) { + if (!nvml_dispatch.nvmlDeviceGetMigDeviceHandleByIndex) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMigDeviceHandleByIndex(device, index, migDevice); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetDeviceHandleFromMigDeviceHandle(nvmlDevice_t migDevice, nvmlDevice_t * device) { + if (!nvml_dispatch.nvmlDeviceGetDeviceHandleFromMigDeviceHandle) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetDeviceHandleFromMigDeviceHandle(migDevice, device); +} + +static inline nvmlReturn_t dispatch_nvmlGpmMetricsGet(nvmlGpmMetricsGet_t * metricsGet) { + if (!nvml_dispatch.nvmlGpmMetricsGet) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpmMetricsGet(metricsGet); +} + +static inline nvmlReturn_t dispatch_nvmlGpmSampleFree(nvmlGpmSample_t gpmSample) { + if (!nvml_dispatch.nvmlGpmSampleFree) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpmSampleFree(gpmSample); +} + +static inline nvmlReturn_t dispatch_nvmlGpmSampleAlloc(nvmlGpmSample_t * gpmSample) { + if (!nvml_dispatch.nvmlGpmSampleAlloc) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpmSampleAlloc(gpmSample); +} + +static inline nvmlReturn_t dispatch_nvmlGpmSampleGet(nvmlDevice_t device, nvmlGpmSample_t gpmSample) { + if (!nvml_dispatch.nvmlGpmSampleGet) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpmSampleGet(device, gpmSample); +} + +static inline nvmlReturn_t dispatch_nvmlGpmMigSampleGet(nvmlDevice_t device, unsigned int gpuInstanceId, nvmlGpmSample_t gpmSample) { + if (!nvml_dispatch.nvmlGpmMigSampleGet) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpmMigSampleGet(device, gpuInstanceId, gpmSample); +} + +static inline nvmlReturn_t dispatch_nvmlGpmQueryDeviceSupport(nvmlDevice_t device, nvmlGpmSupport_t * gpmSupport) { + if (!nvml_dispatch.nvmlGpmQueryDeviceSupport) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpmQueryDeviceSupport(device, gpmSupport); +} + +static inline nvmlReturn_t dispatch_nvmlGpmQueryIfStreamingEnabled(nvmlDevice_t device, unsigned int * state) { + if (!nvml_dispatch.nvmlGpmQueryIfStreamingEnabled) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpmQueryIfStreamingEnabled(device, state); +} + +static inline nvmlReturn_t dispatch_nvmlGpmSetStreamingEnabled(nvmlDevice_t device, unsigned int state) { + if (!nvml_dispatch.nvmlGpmSetStreamingEnabled) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlGpmSetStreamingEnabled(device, state); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetCapabilities(nvmlDevice_t device, nvmlDeviceCapabilities_t * caps) { + if (!nvml_dispatch.nvmlDeviceGetCapabilities) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetCapabilities(device, caps); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceWorkloadPowerProfileGetProfilesInfo(nvmlDevice_t device, nvmlWorkloadPowerProfileProfilesInfo_t * profilesInfo) { + if (!nvml_dispatch.nvmlDeviceWorkloadPowerProfileGetProfilesInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceWorkloadPowerProfileGetProfilesInfo(device, profilesInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceWorkloadPowerProfileGetCurrentProfiles(nvmlDevice_t device, nvmlWorkloadPowerProfileCurrentProfiles_t * currentProfiles) { + if (!nvml_dispatch.nvmlDeviceWorkloadPowerProfileGetCurrentProfiles) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceWorkloadPowerProfileGetCurrentProfiles(device, currentProfiles); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceWorkloadPowerProfileSetRequestedProfiles(nvmlDevice_t device, nvmlWorkloadPowerProfileRequestedProfiles_t * requestedProfiles) { + if (!nvml_dispatch.nvmlDeviceWorkloadPowerProfileSetRequestedProfiles) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceWorkloadPowerProfileSetRequestedProfiles(device, requestedProfiles); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceWorkloadPowerProfileClearRequestedProfiles(nvmlDevice_t device, nvmlWorkloadPowerProfileRequestedProfiles_t * requestedProfiles) { + if (!nvml_dispatch.nvmlDeviceWorkloadPowerProfileClearRequestedProfiles) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceWorkloadPowerProfileClearRequestedProfiles(device, requestedProfiles); +} + +static inline nvmlReturn_t dispatch_nvmlDevicePowerSmoothingActivatePresetProfile(nvmlDevice_t device, nvmlPowerSmoothingProfile_t * profile) { + if (!nvml_dispatch.nvmlDevicePowerSmoothingActivatePresetProfile) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDevicePowerSmoothingActivatePresetProfile(device, profile); +} + +static inline nvmlReturn_t dispatch_nvmlDevicePowerSmoothingUpdatePresetProfileParam(nvmlDevice_t device, nvmlPowerSmoothingProfile_t * profile) { + if (!nvml_dispatch.nvmlDevicePowerSmoothingUpdatePresetProfileParam) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDevicePowerSmoothingUpdatePresetProfileParam(device, profile); +} + +static inline nvmlReturn_t dispatch_nvmlDevicePowerSmoothingSetState(nvmlDevice_t device, nvmlPowerSmoothingState_t * state) { + if (!nvml_dispatch.nvmlDevicePowerSmoothingSetState) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDevicePowerSmoothingSetState(device, state); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts(nvmlDevice_t device, nvmlEccSramUniqueUncorrectedErrorCounts_t * errorCounts) { + if (!nvml_dispatch.nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts(device, errorCounts); +} + +static inline nvmlReturn_t dispatch_nvmlInit(void) { + if (!nvml_dispatch.nvmlInit) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlInit(); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetCount(unsigned int * deviceCount) { + if (!nvml_dispatch.nvmlDeviceGetCount) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetCount(deviceCount); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetHandleByIndex(unsigned int index, nvmlDevice_t * device) { + if (!nvml_dispatch.nvmlDeviceGetHandleByIndex) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetHandleByIndex(index, device); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetHandleByPciBusId(const char * pciBusId, nvmlDevice_t * device) { + if (!nvml_dispatch.nvmlDeviceGetHandleByPciBusId) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetHandleByPciBusId(pciBusId, device); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPciInfo(nvmlDevice_t device, nvmlPciInfo_t * pci) { + if (!nvml_dispatch.nvmlDeviceGetPciInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPciInfo(device, pci); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetPciInfo_v2(nvmlDevice_t device, nvmlPciInfo_t * pci) { + if (!nvml_dispatch.nvmlDeviceGetPciInfo_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetPciInfo_v2(device, pci); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetNvLinkRemotePciInfo(nvmlDevice_t device, unsigned int link, nvmlPciInfo_t * pci) { + if (!nvml_dispatch.nvmlDeviceGetNvLinkRemotePciInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetNvLinkRemotePciInfo(device, link, pci); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGridLicensableFeatures(nvmlDevice_t device, nvmlGridLicensableFeatures_t * pGridLicensableFeatures) { + if (!nvml_dispatch.nvmlDeviceGetGridLicensableFeatures) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGridLicensableFeatures(device, pGridLicensableFeatures); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGridLicensableFeatures_v2(nvmlDevice_t device, nvmlGridLicensableFeatures_t * pGridLicensableFeatures) { + if (!nvml_dispatch.nvmlDeviceGetGridLicensableFeatures_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGridLicensableFeatures_v2(device, pGridLicensableFeatures); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGridLicensableFeatures_v3(nvmlDevice_t device, nvmlGridLicensableFeatures_t * pGridLicensableFeatures) { + if (!nvml_dispatch.nvmlDeviceGetGridLicensableFeatures_v3) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGridLicensableFeatures_v3(device, pGridLicensableFeatures); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceRemoveGpu(nvmlPciInfo_t * pciInfo) { + if (!nvml_dispatch.nvmlDeviceRemoveGpu) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceRemoveGpu(pciInfo); +} + +static inline nvmlReturn_t dispatch_nvmlEventSetWait(nvmlEventSet_t set, nvmlEventData_t * data, unsigned int timeoutms) { + if (!nvml_dispatch.nvmlEventSetWait) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlEventSetWait(set, data, timeoutms); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetAttributes(nvmlDevice_t device, nvmlDeviceAttributes_t * attributes) { + if (!nvml_dispatch.nvmlDeviceGetAttributes) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetAttributes(device, attributes); +} + +static inline nvmlReturn_t dispatch_nvmlComputeInstanceGetInfo(nvmlComputeInstance_t computeInstance, nvmlComputeInstanceInfo_t * info) { + if (!nvml_dispatch.nvmlComputeInstanceGetInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlComputeInstanceGetInfo(computeInstance, info); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetComputeRunningProcesses(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_v1_t * infos) { + if (!nvml_dispatch.nvmlDeviceGetComputeRunningProcesses) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetComputeRunningProcesses(device, infoCount, infos); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetComputeRunningProcesses_v2(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_v2_t * infos) { + if (!nvml_dispatch.nvmlDeviceGetComputeRunningProcesses_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetComputeRunningProcesses_v2(device, infoCount, infos); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGraphicsRunningProcesses(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_v1_t * infos) { + if (!nvml_dispatch.nvmlDeviceGetGraphicsRunningProcesses) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGraphicsRunningProcesses(device, infoCount, infos); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGraphicsRunningProcesses_v2(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_v2_t * infos) { + if (!nvml_dispatch.nvmlDeviceGetGraphicsRunningProcesses_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGraphicsRunningProcesses_v2(device, infoCount, infos); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMPSComputeRunningProcesses(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_v1_t * infos) { + if (!nvml_dispatch.nvmlDeviceGetMPSComputeRunningProcesses) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMPSComputeRunningProcesses(device, infoCount, infos); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetMPSComputeRunningProcesses_v2(nvmlDevice_t device, unsigned int * infoCount, nvmlProcessInfo_v2_t * infos) { + if (!nvml_dispatch.nvmlDeviceGetMPSComputeRunningProcesses_v2) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetMPSComputeRunningProcesses_v2(device, infoCount, infos); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetGpuInstancePossiblePlacements(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstancePlacement_t * placements, unsigned int * count) { + if (!nvml_dispatch.nvmlDeviceGetGpuInstancePossiblePlacements) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetGpuInstancePossiblePlacements(device, profileId, placements, count); +} + +static inline nvmlReturn_t dispatch_nvmlVgpuInstanceGetLicenseInfo(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuLicenseInfo_t * licenseInfo) { + if (!nvml_dispatch.nvmlVgpuInstanceGetLicenseInfo) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlVgpuInstanceGetLicenseInfo(vgpuInstance, licenseInfo); +} + +static inline nvmlReturn_t dispatch_nvmlDeviceGetDriverModel(nvmlDevice_t device, nvmlDriverModel_t * current, nvmlDriverModel_t * pending) { + if (!nvml_dispatch.nvmlDeviceGetDriverModel) return NVML_ERROR_FUNCTION_NOT_FOUND; + return nvml_dispatch.nvmlDeviceGetDriverModel(device, current, pending); +} + + +#endif /* NVML_DISPATCH_H */ diff --git a/pkg/nvml/zz_generated_nvml_dispatch.go b/pkg/nvml/zz_generated_nvml_dispatch.go new file mode 100644 index 00000000..b25ba099 --- /dev/null +++ b/pkg/nvml/zz_generated_nvml_dispatch.go @@ -0,0 +1,440 @@ +// Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// WARNING: THIS FILE WAS AUTOMATICALLY GENERATED. +// Code generated by gen/nvml/gen-dispatch. DO NOT EDIT. + +package nvml + +/* +#include "nvml_dispatch.h" + +// nvml_dispatch is the single global instance of the dispatch table. +// It is populated by populateDispatch() and zeroed by clearDispatch() in Go. +nvml_dispatch_t nvml_dispatch; +*/ +import "C" +import ( + "unsafe" + + "github.com/NVIDIA/go-nvml/pkg/dl" +) + +// populateDispatch resolves all NVML function pointers via the given library +// and stores them in the C dispatch table. +func populateDispatch(lib *dl.DynamicLibrary) error { + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlInit_v2)) = lib.Resolve("nvmlInit_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlInitWithFlags)) = lib.Resolve("nvmlInitWithFlags") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlShutdown)) = lib.Resolve("nvmlShutdown") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlErrorString)) = lib.Resolve("nvmlErrorString") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemGetDriverVersion)) = lib.Resolve("nvmlSystemGetDriverVersion") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemGetNVMLVersion)) = lib.Resolve("nvmlSystemGetNVMLVersion") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemGetCudaDriverVersion)) = lib.Resolve("nvmlSystemGetCudaDriverVersion") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemGetCudaDriverVersion_v2)) = lib.Resolve("nvmlSystemGetCudaDriverVersion_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemGetProcessName)) = lib.Resolve("nvmlSystemGetProcessName") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemGetHicVersion)) = lib.Resolve("nvmlSystemGetHicVersion") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemGetTopologyGpuSet)) = lib.Resolve("nvmlSystemGetTopologyGpuSet") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemGetDriverBranch)) = lib.Resolve("nvmlSystemGetDriverBranch") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlUnitGetCount)) = lib.Resolve("nvmlUnitGetCount") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlUnitGetHandleByIndex)) = lib.Resolve("nvmlUnitGetHandleByIndex") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlUnitGetUnitInfo)) = lib.Resolve("nvmlUnitGetUnitInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlUnitGetLedState)) = lib.Resolve("nvmlUnitGetLedState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlUnitGetPsuInfo)) = lib.Resolve("nvmlUnitGetPsuInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlUnitGetTemperature)) = lib.Resolve("nvmlUnitGetTemperature") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlUnitGetFanSpeedInfo)) = lib.Resolve("nvmlUnitGetFanSpeedInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlUnitGetDevices)) = lib.Resolve("nvmlUnitGetDevices") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetCount_v2)) = lib.Resolve("nvmlDeviceGetCount_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetAttributes_v2)) = lib.Resolve("nvmlDeviceGetAttributes_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetHandleByIndex_v2)) = lib.Resolve("nvmlDeviceGetHandleByIndex_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetHandleBySerial)) = lib.Resolve("nvmlDeviceGetHandleBySerial") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetHandleByUUID)) = lib.Resolve("nvmlDeviceGetHandleByUUID") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetHandleByUUIDV)) = lib.Resolve("nvmlDeviceGetHandleByUUIDV") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetHandleByPciBusId_v2)) = lib.Resolve("nvmlDeviceGetHandleByPciBusId_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetName)) = lib.Resolve("nvmlDeviceGetName") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetBrand)) = lib.Resolve("nvmlDeviceGetBrand") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetIndex)) = lib.Resolve("nvmlDeviceGetIndex") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetSerial)) = lib.Resolve("nvmlDeviceGetSerial") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetModuleId)) = lib.Resolve("nvmlDeviceGetModuleId") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetC2cModeInfoV)) = lib.Resolve("nvmlDeviceGetC2cModeInfoV") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMemoryAffinity)) = lib.Resolve("nvmlDeviceGetMemoryAffinity") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetCpuAffinityWithinScope)) = lib.Resolve("nvmlDeviceGetCpuAffinityWithinScope") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetCpuAffinity)) = lib.Resolve("nvmlDeviceGetCpuAffinity") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetCpuAffinity)) = lib.Resolve("nvmlDeviceSetCpuAffinity") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceClearCpuAffinity)) = lib.Resolve("nvmlDeviceClearCpuAffinity") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNumaNodeId)) = lib.Resolve("nvmlDeviceGetNumaNodeId") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetAddressingMode)) = lib.Resolve("nvmlDeviceGetAddressingMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetRepairStatus)) = lib.Resolve("nvmlDeviceGetRepairStatus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetTopologyCommonAncestor)) = lib.Resolve("nvmlDeviceGetTopologyCommonAncestor") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetTopologyNearestGpus)) = lib.Resolve("nvmlDeviceGetTopologyNearestGpus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetP2PStatus)) = lib.Resolve("nvmlDeviceGetP2PStatus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetUUID)) = lib.Resolve("nvmlDeviceGetUUID") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMinorNumber)) = lib.Resolve("nvmlDeviceGetMinorNumber") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetBoardPartNumber)) = lib.Resolve("nvmlDeviceGetBoardPartNumber") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetInforomVersion)) = lib.Resolve("nvmlDeviceGetInforomVersion") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetInforomImageVersion)) = lib.Resolve("nvmlDeviceGetInforomImageVersion") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetInforomConfigurationChecksum)) = lib.Resolve("nvmlDeviceGetInforomConfigurationChecksum") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceValidateInforom)) = lib.Resolve("nvmlDeviceValidateInforom") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetLastBBXFlushTime)) = lib.Resolve("nvmlDeviceGetLastBBXFlushTime") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetDisplayMode)) = lib.Resolve("nvmlDeviceGetDisplayMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetDisplayActive)) = lib.Resolve("nvmlDeviceGetDisplayActive") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPersistenceMode)) = lib.Resolve("nvmlDeviceGetPersistenceMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPciInfoExt)) = lib.Resolve("nvmlDeviceGetPciInfoExt") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPciInfo_v3)) = lib.Resolve("nvmlDeviceGetPciInfo_v3") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMaxPcieLinkGeneration)) = lib.Resolve("nvmlDeviceGetMaxPcieLinkGeneration") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpuMaxPcieLinkGeneration)) = lib.Resolve("nvmlDeviceGetGpuMaxPcieLinkGeneration") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMaxPcieLinkWidth)) = lib.Resolve("nvmlDeviceGetMaxPcieLinkWidth") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetCurrPcieLinkGeneration)) = lib.Resolve("nvmlDeviceGetCurrPcieLinkGeneration") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetCurrPcieLinkWidth)) = lib.Resolve("nvmlDeviceGetCurrPcieLinkWidth") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPcieThroughput)) = lib.Resolve("nvmlDeviceGetPcieThroughput") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPcieReplayCounter)) = lib.Resolve("nvmlDeviceGetPcieReplayCounter") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetClockInfo)) = lib.Resolve("nvmlDeviceGetClockInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMaxClockInfo)) = lib.Resolve("nvmlDeviceGetMaxClockInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpcClkVfOffset)) = lib.Resolve("nvmlDeviceGetGpcClkVfOffset") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetApplicationsClock)) = lib.Resolve("nvmlDeviceGetApplicationsClock") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetDefaultApplicationsClock)) = lib.Resolve("nvmlDeviceGetDefaultApplicationsClock") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetClock)) = lib.Resolve("nvmlDeviceGetClock") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMaxCustomerBoostClock)) = lib.Resolve("nvmlDeviceGetMaxCustomerBoostClock") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetSupportedMemoryClocks)) = lib.Resolve("nvmlDeviceGetSupportedMemoryClocks") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetSupportedGraphicsClocks)) = lib.Resolve("nvmlDeviceGetSupportedGraphicsClocks") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetAutoBoostedClocksEnabled)) = lib.Resolve("nvmlDeviceGetAutoBoostedClocksEnabled") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetFanSpeed)) = lib.Resolve("nvmlDeviceGetFanSpeed") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetFanSpeed_v2)) = lib.Resolve("nvmlDeviceGetFanSpeed_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetFanSpeedRPM)) = lib.Resolve("nvmlDeviceGetFanSpeedRPM") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetTargetFanSpeed)) = lib.Resolve("nvmlDeviceGetTargetFanSpeed") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMinMaxFanSpeed)) = lib.Resolve("nvmlDeviceGetMinMaxFanSpeed") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetFanControlPolicy_v2)) = lib.Resolve("nvmlDeviceGetFanControlPolicy_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNumFans)) = lib.Resolve("nvmlDeviceGetNumFans") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetTemperature)) = lib.Resolve("nvmlDeviceGetTemperature") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetCoolerInfo)) = lib.Resolve("nvmlDeviceGetCoolerInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetTemperatureV)) = lib.Resolve("nvmlDeviceGetTemperatureV") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetTemperatureThreshold)) = lib.Resolve("nvmlDeviceGetTemperatureThreshold") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMarginTemperature)) = lib.Resolve("nvmlDeviceGetMarginTemperature") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetThermalSettings)) = lib.Resolve("nvmlDeviceGetThermalSettings") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPerformanceState)) = lib.Resolve("nvmlDeviceGetPerformanceState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetCurrentClocksEventReasons)) = lib.Resolve("nvmlDeviceGetCurrentClocksEventReasons") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetCurrentClocksThrottleReasons)) = lib.Resolve("nvmlDeviceGetCurrentClocksThrottleReasons") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetSupportedClocksEventReasons)) = lib.Resolve("nvmlDeviceGetSupportedClocksEventReasons") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetSupportedClocksThrottleReasons)) = lib.Resolve("nvmlDeviceGetSupportedClocksThrottleReasons") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPowerState)) = lib.Resolve("nvmlDeviceGetPowerState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetDynamicPstatesInfo)) = lib.Resolve("nvmlDeviceGetDynamicPstatesInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMemClkVfOffset)) = lib.Resolve("nvmlDeviceGetMemClkVfOffset") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMinMaxClockOfPState)) = lib.Resolve("nvmlDeviceGetMinMaxClockOfPState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetSupportedPerformanceStates)) = lib.Resolve("nvmlDeviceGetSupportedPerformanceStates") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpcClkMinMaxVfOffset)) = lib.Resolve("nvmlDeviceGetGpcClkMinMaxVfOffset") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMemClkMinMaxVfOffset)) = lib.Resolve("nvmlDeviceGetMemClkMinMaxVfOffset") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetClockOffsets)) = lib.Resolve("nvmlDeviceGetClockOffsets") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetClockOffsets)) = lib.Resolve("nvmlDeviceSetClockOffsets") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPerformanceModes)) = lib.Resolve("nvmlDeviceGetPerformanceModes") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetCurrentClockFreqs)) = lib.Resolve("nvmlDeviceGetCurrentClockFreqs") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPowerManagementMode)) = lib.Resolve("nvmlDeviceGetPowerManagementMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPowerManagementLimit)) = lib.Resolve("nvmlDeviceGetPowerManagementLimit") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPowerManagementLimitConstraints)) = lib.Resolve("nvmlDeviceGetPowerManagementLimitConstraints") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPowerManagementDefaultLimit)) = lib.Resolve("nvmlDeviceGetPowerManagementDefaultLimit") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPowerUsage)) = lib.Resolve("nvmlDeviceGetPowerUsage") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPowerMizerMode_v1)) = lib.Resolve("nvmlDeviceGetPowerMizerMode_v1") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetPowerMizerMode_v1)) = lib.Resolve("nvmlDeviceSetPowerMizerMode_v1") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetTotalEnergyConsumption)) = lib.Resolve("nvmlDeviceGetTotalEnergyConsumption") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetEnforcedPowerLimit)) = lib.Resolve("nvmlDeviceGetEnforcedPowerLimit") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpuOperationMode)) = lib.Resolve("nvmlDeviceGetGpuOperationMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMemoryInfo)) = lib.Resolve("nvmlDeviceGetMemoryInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMemoryInfo_v2)) = lib.Resolve("nvmlDeviceGetMemoryInfo_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetComputeMode)) = lib.Resolve("nvmlDeviceGetComputeMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetCudaComputeCapability)) = lib.Resolve("nvmlDeviceGetCudaComputeCapability") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetDramEncryptionMode)) = lib.Resolve("nvmlDeviceGetDramEncryptionMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetDramEncryptionMode)) = lib.Resolve("nvmlDeviceSetDramEncryptionMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetEccMode)) = lib.Resolve("nvmlDeviceGetEccMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetDefaultEccMode)) = lib.Resolve("nvmlDeviceGetDefaultEccMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetBoardId)) = lib.Resolve("nvmlDeviceGetBoardId") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMultiGpuBoard)) = lib.Resolve("nvmlDeviceGetMultiGpuBoard") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetTotalEccErrors)) = lib.Resolve("nvmlDeviceGetTotalEccErrors") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetDetailedEccErrors)) = lib.Resolve("nvmlDeviceGetDetailedEccErrors") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMemoryErrorCounter)) = lib.Resolve("nvmlDeviceGetMemoryErrorCounter") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetUtilizationRates)) = lib.Resolve("nvmlDeviceGetUtilizationRates") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetEncoderUtilization)) = lib.Resolve("nvmlDeviceGetEncoderUtilization") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetEncoderCapacity)) = lib.Resolve("nvmlDeviceGetEncoderCapacity") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetEncoderStats)) = lib.Resolve("nvmlDeviceGetEncoderStats") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetEncoderSessions)) = lib.Resolve("nvmlDeviceGetEncoderSessions") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetDecoderUtilization)) = lib.Resolve("nvmlDeviceGetDecoderUtilization") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetJpgUtilization)) = lib.Resolve("nvmlDeviceGetJpgUtilization") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetOfaUtilization)) = lib.Resolve("nvmlDeviceGetOfaUtilization") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetFBCStats)) = lib.Resolve("nvmlDeviceGetFBCStats") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetFBCSessions)) = lib.Resolve("nvmlDeviceGetFBCSessions") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetDriverModel_v2)) = lib.Resolve("nvmlDeviceGetDriverModel_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetVbiosVersion)) = lib.Resolve("nvmlDeviceGetVbiosVersion") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetBridgeChipInfo)) = lib.Resolve("nvmlDeviceGetBridgeChipInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetComputeRunningProcesses_v3)) = lib.Resolve("nvmlDeviceGetComputeRunningProcesses_v3") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGraphicsRunningProcesses_v3)) = lib.Resolve("nvmlDeviceGetGraphicsRunningProcesses_v3") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMPSComputeRunningProcesses_v3)) = lib.Resolve("nvmlDeviceGetMPSComputeRunningProcesses_v3") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetRunningProcessDetailList)) = lib.Resolve("nvmlDeviceGetRunningProcessDetailList") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceOnSameBoard)) = lib.Resolve("nvmlDeviceOnSameBoard") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetAPIRestriction)) = lib.Resolve("nvmlDeviceGetAPIRestriction") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetSamples)) = lib.Resolve("nvmlDeviceGetSamples") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetBAR1MemoryInfo)) = lib.Resolve("nvmlDeviceGetBAR1MemoryInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetViolationStatus)) = lib.Resolve("nvmlDeviceGetViolationStatus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetIrqNum)) = lib.Resolve("nvmlDeviceGetIrqNum") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNumGpuCores)) = lib.Resolve("nvmlDeviceGetNumGpuCores") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPowerSource)) = lib.Resolve("nvmlDeviceGetPowerSource") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMemoryBusWidth)) = lib.Resolve("nvmlDeviceGetMemoryBusWidth") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPcieLinkMaxSpeed)) = lib.Resolve("nvmlDeviceGetPcieLinkMaxSpeed") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPcieSpeed)) = lib.Resolve("nvmlDeviceGetPcieSpeed") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetAdaptiveClockInfoStatus)) = lib.Resolve("nvmlDeviceGetAdaptiveClockInfoStatus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetBusType)) = lib.Resolve("nvmlDeviceGetBusType") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpuFabricInfo)) = lib.Resolve("nvmlDeviceGetGpuFabricInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpuFabricInfoV)) = lib.Resolve("nvmlDeviceGetGpuFabricInfoV") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemGetConfComputeCapabilities)) = lib.Resolve("nvmlSystemGetConfComputeCapabilities") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemGetConfComputeState)) = lib.Resolve("nvmlSystemGetConfComputeState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetConfComputeMemSizeInfo)) = lib.Resolve("nvmlDeviceGetConfComputeMemSizeInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemGetConfComputeGpusReadyState)) = lib.Resolve("nvmlSystemGetConfComputeGpusReadyState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetConfComputeProtectedMemoryUsage)) = lib.Resolve("nvmlDeviceGetConfComputeProtectedMemoryUsage") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetConfComputeGpuCertificate)) = lib.Resolve("nvmlDeviceGetConfComputeGpuCertificate") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetConfComputeGpuAttestationReport)) = lib.Resolve("nvmlDeviceGetConfComputeGpuAttestationReport") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemGetConfComputeKeyRotationThresholdInfo)) = lib.Resolve("nvmlSystemGetConfComputeKeyRotationThresholdInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetConfComputeUnprotectedMemSize)) = lib.Resolve("nvmlDeviceSetConfComputeUnprotectedMemSize") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemSetConfComputeGpusReadyState)) = lib.Resolve("nvmlSystemSetConfComputeGpusReadyState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemSetConfComputeKeyRotationThresholdInfo)) = lib.Resolve("nvmlSystemSetConfComputeKeyRotationThresholdInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemGetConfComputeSettings)) = lib.Resolve("nvmlSystemGetConfComputeSettings") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGspFirmwareVersion)) = lib.Resolve("nvmlDeviceGetGspFirmwareVersion") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGspFirmwareMode)) = lib.Resolve("nvmlDeviceGetGspFirmwareMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetSramEccErrorStatus)) = lib.Resolve("nvmlDeviceGetSramEccErrorStatus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetPowerManagementLimit_v2)) = lib.Resolve("nvmlDeviceSetPowerManagementLimit_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetAccountingMode)) = lib.Resolve("nvmlDeviceGetAccountingMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetAccountingStats)) = lib.Resolve("nvmlDeviceGetAccountingStats") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetAccountingPids)) = lib.Resolve("nvmlDeviceGetAccountingPids") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetAccountingBufferSize)) = lib.Resolve("nvmlDeviceGetAccountingBufferSize") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetRetiredPages)) = lib.Resolve("nvmlDeviceGetRetiredPages") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetRetiredPages_v2)) = lib.Resolve("nvmlDeviceGetRetiredPages_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetRetiredPagesPendingStatus)) = lib.Resolve("nvmlDeviceGetRetiredPagesPendingStatus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetRemappedRows)) = lib.Resolve("nvmlDeviceGetRemappedRows") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetRowRemapperHistogram)) = lib.Resolve("nvmlDeviceGetRowRemapperHistogram") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetArchitecture)) = lib.Resolve("nvmlDeviceGetArchitecture") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetClkMonStatus)) = lib.Resolve("nvmlDeviceGetClkMonStatus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetProcessUtilization)) = lib.Resolve("nvmlDeviceGetProcessUtilization") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetProcessesUtilizationInfo)) = lib.Resolve("nvmlDeviceGetProcessesUtilizationInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPlatformInfo)) = lib.Resolve("nvmlDeviceGetPlatformInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPdi)) = lib.Resolve("nvmlDeviceGetPdi") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlUnitSetLedState)) = lib.Resolve("nvmlUnitSetLedState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetPersistenceMode)) = lib.Resolve("nvmlDeviceSetPersistenceMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetComputeMode)) = lib.Resolve("nvmlDeviceSetComputeMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetEccMode)) = lib.Resolve("nvmlDeviceSetEccMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceClearEccErrorCounts)) = lib.Resolve("nvmlDeviceClearEccErrorCounts") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetDriverModel)) = lib.Resolve("nvmlDeviceSetDriverModel") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetGpuLockedClocks)) = lib.Resolve("nvmlDeviceSetGpuLockedClocks") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceResetGpuLockedClocks)) = lib.Resolve("nvmlDeviceResetGpuLockedClocks") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetMemoryLockedClocks)) = lib.Resolve("nvmlDeviceSetMemoryLockedClocks") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceResetMemoryLockedClocks)) = lib.Resolve("nvmlDeviceResetMemoryLockedClocks") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetApplicationsClocks)) = lib.Resolve("nvmlDeviceSetApplicationsClocks") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceResetApplicationsClocks)) = lib.Resolve("nvmlDeviceResetApplicationsClocks") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetAutoBoostedClocksEnabled)) = lib.Resolve("nvmlDeviceSetAutoBoostedClocksEnabled") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetDefaultAutoBoostedClocksEnabled)) = lib.Resolve("nvmlDeviceSetDefaultAutoBoostedClocksEnabled") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetDefaultFanSpeed_v2)) = lib.Resolve("nvmlDeviceSetDefaultFanSpeed_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetFanControlPolicy)) = lib.Resolve("nvmlDeviceSetFanControlPolicy") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetTemperatureThreshold)) = lib.Resolve("nvmlDeviceSetTemperatureThreshold") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetPowerManagementLimit)) = lib.Resolve("nvmlDeviceSetPowerManagementLimit") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetGpuOperationMode)) = lib.Resolve("nvmlDeviceSetGpuOperationMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetAPIRestriction)) = lib.Resolve("nvmlDeviceSetAPIRestriction") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetFanSpeed_v2)) = lib.Resolve("nvmlDeviceSetFanSpeed_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetGpcClkVfOffset)) = lib.Resolve("nvmlDeviceSetGpcClkVfOffset") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetMemClkVfOffset)) = lib.Resolve("nvmlDeviceSetMemClkVfOffset") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetAccountingMode)) = lib.Resolve("nvmlDeviceSetAccountingMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceClearAccountingPids)) = lib.Resolve("nvmlDeviceClearAccountingPids") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNvLinkState)) = lib.Resolve("nvmlDeviceGetNvLinkState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNvLinkVersion)) = lib.Resolve("nvmlDeviceGetNvLinkVersion") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNvLinkCapability)) = lib.Resolve("nvmlDeviceGetNvLinkCapability") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNvLinkRemotePciInfo_v2)) = lib.Resolve("nvmlDeviceGetNvLinkRemotePciInfo_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNvLinkErrorCounter)) = lib.Resolve("nvmlDeviceGetNvLinkErrorCounter") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceResetNvLinkErrorCounters)) = lib.Resolve("nvmlDeviceResetNvLinkErrorCounters") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetNvLinkUtilizationControl)) = lib.Resolve("nvmlDeviceSetNvLinkUtilizationControl") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNvLinkUtilizationControl)) = lib.Resolve("nvmlDeviceGetNvLinkUtilizationControl") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNvLinkUtilizationCounter)) = lib.Resolve("nvmlDeviceGetNvLinkUtilizationCounter") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceFreezeNvLinkUtilizationCounter)) = lib.Resolve("nvmlDeviceFreezeNvLinkUtilizationCounter") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceResetNvLinkUtilizationCounter)) = lib.Resolve("nvmlDeviceResetNvLinkUtilizationCounter") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNvLinkRemoteDeviceType)) = lib.Resolve("nvmlDeviceGetNvLinkRemoteDeviceType") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetNvLinkDeviceLowPowerThreshold)) = lib.Resolve("nvmlDeviceSetNvLinkDeviceLowPowerThreshold") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemSetNvlinkBwMode)) = lib.Resolve("nvmlSystemSetNvlinkBwMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemGetNvlinkBwMode)) = lib.Resolve("nvmlSystemGetNvlinkBwMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNvlinkSupportedBwModes)) = lib.Resolve("nvmlDeviceGetNvlinkSupportedBwModes") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNvlinkBwMode)) = lib.Resolve("nvmlDeviceGetNvlinkBwMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetNvlinkBwMode)) = lib.Resolve("nvmlDeviceSetNvlinkBwMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNvLinkInfo)) = lib.Resolve("nvmlDeviceGetNvLinkInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlEventSetCreate)) = lib.Resolve("nvmlEventSetCreate") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceRegisterEvents)) = lib.Resolve("nvmlDeviceRegisterEvents") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetSupportedEventTypes)) = lib.Resolve("nvmlDeviceGetSupportedEventTypes") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlEventSetWait_v2)) = lib.Resolve("nvmlEventSetWait_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlEventSetFree)) = lib.Resolve("nvmlEventSetFree") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemEventSetCreate)) = lib.Resolve("nvmlSystemEventSetCreate") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemEventSetFree)) = lib.Resolve("nvmlSystemEventSetFree") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemRegisterEvents)) = lib.Resolve("nvmlSystemRegisterEvents") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSystemEventSetWait)) = lib.Resolve("nvmlSystemEventSetWait") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceModifyDrainState)) = lib.Resolve("nvmlDeviceModifyDrainState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceQueryDrainState)) = lib.Resolve("nvmlDeviceQueryDrainState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceRemoveGpu_v2)) = lib.Resolve("nvmlDeviceRemoveGpu_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceDiscoverGpus)) = lib.Resolve("nvmlDeviceDiscoverGpus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetFieldValues)) = lib.Resolve("nvmlDeviceGetFieldValues") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceClearFieldValues)) = lib.Resolve("nvmlDeviceClearFieldValues") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetVirtualizationMode)) = lib.Resolve("nvmlDeviceGetVirtualizationMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetHostVgpuMode)) = lib.Resolve("nvmlDeviceGetHostVgpuMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetVirtualizationMode)) = lib.Resolve("nvmlDeviceSetVirtualizationMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetVgpuHeterogeneousMode)) = lib.Resolve("nvmlDeviceGetVgpuHeterogeneousMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetVgpuHeterogeneousMode)) = lib.Resolve("nvmlDeviceSetVgpuHeterogeneousMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetPlacementId)) = lib.Resolve("nvmlVgpuInstanceGetPlacementId") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetVgpuTypeSupportedPlacements)) = lib.Resolve("nvmlDeviceGetVgpuTypeSupportedPlacements") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetVgpuTypeCreatablePlacements)) = lib.Resolve("nvmlDeviceGetVgpuTypeCreatablePlacements") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetGspHeapSize)) = lib.Resolve("nvmlVgpuTypeGetGspHeapSize") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetFbReservation)) = lib.Resolve("nvmlVgpuTypeGetFbReservation") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetRuntimeStateSize)) = lib.Resolve("nvmlVgpuInstanceGetRuntimeStateSize") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetVgpuCapabilities)) = lib.Resolve("nvmlDeviceSetVgpuCapabilities") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGridLicensableFeatures_v4)) = lib.Resolve("nvmlDeviceGetGridLicensableFeatures_v4") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGetVgpuDriverCapabilities)) = lib.Resolve("nvmlGetVgpuDriverCapabilities") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetVgpuCapabilities)) = lib.Resolve("nvmlDeviceGetVgpuCapabilities") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetSupportedVgpus)) = lib.Resolve("nvmlDeviceGetSupportedVgpus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetCreatableVgpus)) = lib.Resolve("nvmlDeviceGetCreatableVgpus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetClass)) = lib.Resolve("nvmlVgpuTypeGetClass") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetName)) = lib.Resolve("nvmlVgpuTypeGetName") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetGpuInstanceProfileId)) = lib.Resolve("nvmlVgpuTypeGetGpuInstanceProfileId") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetDeviceID)) = lib.Resolve("nvmlVgpuTypeGetDeviceID") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetFramebufferSize)) = lib.Resolve("nvmlVgpuTypeGetFramebufferSize") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetNumDisplayHeads)) = lib.Resolve("nvmlVgpuTypeGetNumDisplayHeads") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetResolution)) = lib.Resolve("nvmlVgpuTypeGetResolution") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetLicense)) = lib.Resolve("nvmlVgpuTypeGetLicense") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetFrameRateLimit)) = lib.Resolve("nvmlVgpuTypeGetFrameRateLimit") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetMaxInstances)) = lib.Resolve("nvmlVgpuTypeGetMaxInstances") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetMaxInstancesPerVm)) = lib.Resolve("nvmlVgpuTypeGetMaxInstancesPerVm") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetBAR1Info)) = lib.Resolve("nvmlVgpuTypeGetBAR1Info") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetActiveVgpus)) = lib.Resolve("nvmlDeviceGetActiveVgpus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetVmID)) = lib.Resolve("nvmlVgpuInstanceGetVmID") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetUUID)) = lib.Resolve("nvmlVgpuInstanceGetUUID") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetVmDriverVersion)) = lib.Resolve("nvmlVgpuInstanceGetVmDriverVersion") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetFbUsage)) = lib.Resolve("nvmlVgpuInstanceGetFbUsage") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetLicenseStatus)) = lib.Resolve("nvmlVgpuInstanceGetLicenseStatus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetType)) = lib.Resolve("nvmlVgpuInstanceGetType") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetFrameRateLimit)) = lib.Resolve("nvmlVgpuInstanceGetFrameRateLimit") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetEccMode)) = lib.Resolve("nvmlVgpuInstanceGetEccMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetEncoderCapacity)) = lib.Resolve("nvmlVgpuInstanceGetEncoderCapacity") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceSetEncoderCapacity)) = lib.Resolve("nvmlVgpuInstanceSetEncoderCapacity") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetEncoderStats)) = lib.Resolve("nvmlVgpuInstanceGetEncoderStats") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetEncoderSessions)) = lib.Resolve("nvmlVgpuInstanceGetEncoderSessions") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetFBCStats)) = lib.Resolve("nvmlVgpuInstanceGetFBCStats") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetFBCSessions)) = lib.Resolve("nvmlVgpuInstanceGetFBCSessions") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetGpuInstanceId)) = lib.Resolve("nvmlVgpuInstanceGetGpuInstanceId") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetGpuPciId)) = lib.Resolve("nvmlVgpuInstanceGetGpuPciId") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetCapabilities)) = lib.Resolve("nvmlVgpuTypeGetCapabilities") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetMdevUUID)) = lib.Resolve("nvmlVgpuInstanceGetMdevUUID") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceGetCreatableVgpus)) = lib.Resolve("nvmlGpuInstanceGetCreatableVgpus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuTypeGetMaxInstancesPerGpuInstance)) = lib.Resolve("nvmlVgpuTypeGetMaxInstancesPerGpuInstance") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceGetActiveVgpus)) = lib.Resolve("nvmlGpuInstanceGetActiveVgpus") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceSetVgpuSchedulerState)) = lib.Resolve("nvmlGpuInstanceSetVgpuSchedulerState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceGetVgpuSchedulerState)) = lib.Resolve("nvmlGpuInstanceGetVgpuSchedulerState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceGetVgpuSchedulerLog)) = lib.Resolve("nvmlGpuInstanceGetVgpuSchedulerLog") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceGetVgpuTypeCreatablePlacements)) = lib.Resolve("nvmlGpuInstanceGetVgpuTypeCreatablePlacements") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceGetVgpuHeterogeneousMode)) = lib.Resolve("nvmlGpuInstanceGetVgpuHeterogeneousMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceSetVgpuHeterogeneousMode)) = lib.Resolve("nvmlGpuInstanceSetVgpuHeterogeneousMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetMetadata)) = lib.Resolve("nvmlVgpuInstanceGetMetadata") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetVgpuMetadata)) = lib.Resolve("nvmlDeviceGetVgpuMetadata") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGetVgpuCompatibility)) = lib.Resolve("nvmlGetVgpuCompatibility") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPgpuMetadataString)) = lib.Resolve("nvmlDeviceGetPgpuMetadataString") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetVgpuSchedulerLog)) = lib.Resolve("nvmlDeviceGetVgpuSchedulerLog") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetVgpuSchedulerState)) = lib.Resolve("nvmlDeviceGetVgpuSchedulerState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetVgpuSchedulerCapabilities)) = lib.Resolve("nvmlDeviceGetVgpuSchedulerCapabilities") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetVgpuSchedulerState)) = lib.Resolve("nvmlDeviceSetVgpuSchedulerState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGetVgpuVersion)) = lib.Resolve("nvmlGetVgpuVersion") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlSetVgpuVersion)) = lib.Resolve("nvmlSetVgpuVersion") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetVgpuUtilization)) = lib.Resolve("nvmlDeviceGetVgpuUtilization") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetVgpuInstancesUtilizationInfo)) = lib.Resolve("nvmlDeviceGetVgpuInstancesUtilizationInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetVgpuProcessUtilization)) = lib.Resolve("nvmlDeviceGetVgpuProcessUtilization") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetVgpuProcessesUtilizationInfo)) = lib.Resolve("nvmlDeviceGetVgpuProcessesUtilizationInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetAccountingMode)) = lib.Resolve("nvmlVgpuInstanceGetAccountingMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetAccountingPids)) = lib.Resolve("nvmlVgpuInstanceGetAccountingPids") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetAccountingStats)) = lib.Resolve("nvmlVgpuInstanceGetAccountingStats") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceClearAccountingPids)) = lib.Resolve("nvmlVgpuInstanceClearAccountingPids") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetLicenseInfo_v2)) = lib.Resolve("nvmlVgpuInstanceGetLicenseInfo_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGetExcludedDeviceCount)) = lib.Resolve("nvmlGetExcludedDeviceCount") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGetExcludedDeviceInfoByIndex)) = lib.Resolve("nvmlGetExcludedDeviceInfoByIndex") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceReadWritePRM_v1)) = lib.Resolve("nvmlDeviceReadWritePRM_v1") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceSetMigMode)) = lib.Resolve("nvmlDeviceSetMigMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMigMode)) = lib.Resolve("nvmlDeviceGetMigMode") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpuInstanceProfileInfo)) = lib.Resolve("nvmlDeviceGetGpuInstanceProfileInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpuInstanceProfileInfoV)) = lib.Resolve("nvmlDeviceGetGpuInstanceProfileInfoV") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpuInstanceProfileInfoByIdV)) = lib.Resolve("nvmlDeviceGetGpuInstanceProfileInfoByIdV") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpuInstancePossiblePlacements_v2)) = lib.Resolve("nvmlDeviceGetGpuInstancePossiblePlacements_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpuInstanceRemainingCapacity)) = lib.Resolve("nvmlDeviceGetGpuInstanceRemainingCapacity") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceCreateGpuInstance)) = lib.Resolve("nvmlDeviceCreateGpuInstance") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceCreateGpuInstanceWithPlacement)) = lib.Resolve("nvmlDeviceCreateGpuInstanceWithPlacement") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceDestroy)) = lib.Resolve("nvmlGpuInstanceDestroy") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpuInstances)) = lib.Resolve("nvmlDeviceGetGpuInstances") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpuInstanceById)) = lib.Resolve("nvmlDeviceGetGpuInstanceById") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceGetInfo)) = lib.Resolve("nvmlGpuInstanceGetInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceGetComputeInstanceProfileInfo)) = lib.Resolve("nvmlGpuInstanceGetComputeInstanceProfileInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceGetComputeInstanceProfileInfoV)) = lib.Resolve("nvmlGpuInstanceGetComputeInstanceProfileInfoV") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceGetComputeInstanceRemainingCapacity)) = lib.Resolve("nvmlGpuInstanceGetComputeInstanceRemainingCapacity") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceGetComputeInstancePossiblePlacements)) = lib.Resolve("nvmlGpuInstanceGetComputeInstancePossiblePlacements") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceCreateComputeInstance)) = lib.Resolve("nvmlGpuInstanceCreateComputeInstance") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceCreateComputeInstanceWithPlacement)) = lib.Resolve("nvmlGpuInstanceCreateComputeInstanceWithPlacement") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlComputeInstanceDestroy)) = lib.Resolve("nvmlComputeInstanceDestroy") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceGetComputeInstances)) = lib.Resolve("nvmlGpuInstanceGetComputeInstances") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpuInstanceGetComputeInstanceById)) = lib.Resolve("nvmlGpuInstanceGetComputeInstanceById") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlComputeInstanceGetInfo_v2)) = lib.Resolve("nvmlComputeInstanceGetInfo_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceIsMigDeviceHandle)) = lib.Resolve("nvmlDeviceIsMigDeviceHandle") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpuInstanceId)) = lib.Resolve("nvmlDeviceGetGpuInstanceId") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetComputeInstanceId)) = lib.Resolve("nvmlDeviceGetComputeInstanceId") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMaxMigDeviceCount)) = lib.Resolve("nvmlDeviceGetMaxMigDeviceCount") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMigDeviceHandleByIndex)) = lib.Resolve("nvmlDeviceGetMigDeviceHandleByIndex") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetDeviceHandleFromMigDeviceHandle)) = lib.Resolve("nvmlDeviceGetDeviceHandleFromMigDeviceHandle") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpmMetricsGet)) = lib.Resolve("nvmlGpmMetricsGet") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpmSampleFree)) = lib.Resolve("nvmlGpmSampleFree") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpmSampleAlloc)) = lib.Resolve("nvmlGpmSampleAlloc") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpmSampleGet)) = lib.Resolve("nvmlGpmSampleGet") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpmMigSampleGet)) = lib.Resolve("nvmlGpmMigSampleGet") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpmQueryDeviceSupport)) = lib.Resolve("nvmlGpmQueryDeviceSupport") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpmQueryIfStreamingEnabled)) = lib.Resolve("nvmlGpmQueryIfStreamingEnabled") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlGpmSetStreamingEnabled)) = lib.Resolve("nvmlGpmSetStreamingEnabled") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetCapabilities)) = lib.Resolve("nvmlDeviceGetCapabilities") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceWorkloadPowerProfileGetProfilesInfo)) = lib.Resolve("nvmlDeviceWorkloadPowerProfileGetProfilesInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceWorkloadPowerProfileGetCurrentProfiles)) = lib.Resolve("nvmlDeviceWorkloadPowerProfileGetCurrentProfiles") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceWorkloadPowerProfileSetRequestedProfiles)) = lib.Resolve("nvmlDeviceWorkloadPowerProfileSetRequestedProfiles") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceWorkloadPowerProfileClearRequestedProfiles)) = lib.Resolve("nvmlDeviceWorkloadPowerProfileClearRequestedProfiles") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDevicePowerSmoothingActivatePresetProfile)) = lib.Resolve("nvmlDevicePowerSmoothingActivatePresetProfile") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDevicePowerSmoothingUpdatePresetProfileParam)) = lib.Resolve("nvmlDevicePowerSmoothingUpdatePresetProfileParam") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDevicePowerSmoothingSetState)) = lib.Resolve("nvmlDevicePowerSmoothingSetState") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts)) = lib.Resolve("nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlInit)) = lib.Resolve("nvmlInit") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetCount)) = lib.Resolve("nvmlDeviceGetCount") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetHandleByIndex)) = lib.Resolve("nvmlDeviceGetHandleByIndex") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetHandleByPciBusId)) = lib.Resolve("nvmlDeviceGetHandleByPciBusId") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPciInfo)) = lib.Resolve("nvmlDeviceGetPciInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetPciInfo_v2)) = lib.Resolve("nvmlDeviceGetPciInfo_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetNvLinkRemotePciInfo)) = lib.Resolve("nvmlDeviceGetNvLinkRemotePciInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGridLicensableFeatures)) = lib.Resolve("nvmlDeviceGetGridLicensableFeatures") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGridLicensableFeatures_v2)) = lib.Resolve("nvmlDeviceGetGridLicensableFeatures_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGridLicensableFeatures_v3)) = lib.Resolve("nvmlDeviceGetGridLicensableFeatures_v3") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceRemoveGpu)) = lib.Resolve("nvmlDeviceRemoveGpu") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlEventSetWait)) = lib.Resolve("nvmlEventSetWait") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetAttributes)) = lib.Resolve("nvmlDeviceGetAttributes") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlComputeInstanceGetInfo)) = lib.Resolve("nvmlComputeInstanceGetInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetComputeRunningProcesses)) = lib.Resolve("nvmlDeviceGetComputeRunningProcesses") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetComputeRunningProcesses_v2)) = lib.Resolve("nvmlDeviceGetComputeRunningProcesses_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGraphicsRunningProcesses)) = lib.Resolve("nvmlDeviceGetGraphicsRunningProcesses") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGraphicsRunningProcesses_v2)) = lib.Resolve("nvmlDeviceGetGraphicsRunningProcesses_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMPSComputeRunningProcesses)) = lib.Resolve("nvmlDeviceGetMPSComputeRunningProcesses") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetMPSComputeRunningProcesses_v2)) = lib.Resolve("nvmlDeviceGetMPSComputeRunningProcesses_v2") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetGpuInstancePossiblePlacements)) = lib.Resolve("nvmlDeviceGetGpuInstancePossiblePlacements") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlVgpuInstanceGetLicenseInfo)) = lib.Resolve("nvmlVgpuInstanceGetLicenseInfo") + *(*unsafe.Pointer)(unsafe.Pointer(&C.nvml_dispatch.nvmlDeviceGetDriverModel)) = lib.Resolve("nvmlDeviceGetDriverModel") + return nil +} + +// clearDispatch zeros the dispatch table, preventing calls into an unloaded library. +func clearDispatch(_ *dl.DynamicLibrary) error { + C.nvml_dispatch = C.nvml_dispatch_t{} + return nil +}