mirror of
https://github.com/NVIDIA/nvidia-container-toolkit
synced 2024-12-02 00:54:48 +00:00
13589 lines
520 KiB
Go
13589 lines
520 KiB
Go
// Code generated by moq; DO NOT EDIT.
|
|
// github.com/matryer/moq
|
|
|
|
package mock
|
|
|
|
import (
|
|
"github.com/NVIDIA/go-nvml/pkg/nvml"
|
|
"sync"
|
|
)
|
|
|
|
// Ensure, that Interface does implement nvml.Interface.
|
|
// If this is not the case, regenerate this file with moq.
|
|
var _ nvml.Interface = &Interface{}
|
|
|
|
// Interface is a mock implementation of nvml.Interface.
|
|
//
|
|
// func TestSomethingThatUsesInterface(t *testing.T) {
|
|
//
|
|
// // make and configure a mocked nvml.Interface
|
|
// mockedInterface := &Interface{
|
|
// ComputeInstanceDestroyFunc: func(computeInstance nvml.ComputeInstance) nvml.Return {
|
|
// panic("mock out the ComputeInstanceDestroy method")
|
|
// },
|
|
// ComputeInstanceGetInfoFunc: func(computeInstance nvml.ComputeInstance) (nvml.ComputeInstanceInfo, nvml.Return) {
|
|
// panic("mock out the ComputeInstanceGetInfo method")
|
|
// },
|
|
// DeviceCcuGetStreamStateFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceCcuGetStreamState method")
|
|
// },
|
|
// DeviceCcuSetStreamStateFunc: func(device nvml.Device, n int) nvml.Return {
|
|
// panic("mock out the DeviceCcuSetStreamState method")
|
|
// },
|
|
// DeviceClearAccountingPidsFunc: func(device nvml.Device) nvml.Return {
|
|
// panic("mock out the DeviceClearAccountingPids method")
|
|
// },
|
|
// DeviceClearCpuAffinityFunc: func(device nvml.Device) nvml.Return {
|
|
// panic("mock out the DeviceClearCpuAffinity method")
|
|
// },
|
|
// DeviceClearEccErrorCountsFunc: func(device nvml.Device, eccCounterType nvml.EccCounterType) nvml.Return {
|
|
// panic("mock out the DeviceClearEccErrorCounts method")
|
|
// },
|
|
// DeviceClearFieldValuesFunc: func(device nvml.Device, fieldValues []nvml.FieldValue) nvml.Return {
|
|
// panic("mock out the DeviceClearFieldValues method")
|
|
// },
|
|
// DeviceCreateGpuInstanceFunc: func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (nvml.GpuInstance, nvml.Return) {
|
|
// panic("mock out the DeviceCreateGpuInstance method")
|
|
// },
|
|
// DeviceCreateGpuInstanceWithPlacementFunc: func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo, gpuInstancePlacement *nvml.GpuInstancePlacement) (nvml.GpuInstance, nvml.Return) {
|
|
// panic("mock out the DeviceCreateGpuInstanceWithPlacement method")
|
|
// },
|
|
// DeviceDiscoverGpusFunc: func() (nvml.PciInfo, nvml.Return) {
|
|
// panic("mock out the DeviceDiscoverGpus method")
|
|
// },
|
|
// DeviceFreezeNvLinkUtilizationCounterFunc: func(device nvml.Device, n1 int, n2 int, enableState nvml.EnableState) nvml.Return {
|
|
// panic("mock out the DeviceFreezeNvLinkUtilizationCounter method")
|
|
// },
|
|
// DeviceGetAPIRestrictionFunc: func(device nvml.Device, restrictedAPI nvml.RestrictedAPI) (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the DeviceGetAPIRestriction method")
|
|
// },
|
|
// DeviceGetAccountingBufferSizeFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetAccountingBufferSize method")
|
|
// },
|
|
// DeviceGetAccountingModeFunc: func(device nvml.Device) (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the DeviceGetAccountingMode method")
|
|
// },
|
|
// DeviceGetAccountingPidsFunc: func(device nvml.Device) ([]int, nvml.Return) {
|
|
// panic("mock out the DeviceGetAccountingPids method")
|
|
// },
|
|
// DeviceGetAccountingStatsFunc: func(device nvml.Device, v uint32) (nvml.AccountingStats, nvml.Return) {
|
|
// panic("mock out the DeviceGetAccountingStats method")
|
|
// },
|
|
// DeviceGetActiveVgpusFunc: func(device nvml.Device) ([]nvml.VgpuInstance, nvml.Return) {
|
|
// panic("mock out the DeviceGetActiveVgpus method")
|
|
// },
|
|
// DeviceGetAdaptiveClockInfoStatusFunc: func(device nvml.Device) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetAdaptiveClockInfoStatus method")
|
|
// },
|
|
// DeviceGetApplicationsClockFunc: func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetApplicationsClock method")
|
|
// },
|
|
// DeviceGetArchitectureFunc: func(device nvml.Device) (nvml.DeviceArchitecture, nvml.Return) {
|
|
// panic("mock out the DeviceGetArchitecture method")
|
|
// },
|
|
// DeviceGetAttributesFunc: func(device nvml.Device) (nvml.DeviceAttributes, nvml.Return) {
|
|
// panic("mock out the DeviceGetAttributes method")
|
|
// },
|
|
// DeviceGetAutoBoostedClocksEnabledFunc: func(device nvml.Device) (nvml.EnableState, nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the DeviceGetAutoBoostedClocksEnabled method")
|
|
// },
|
|
// DeviceGetBAR1MemoryInfoFunc: func(device nvml.Device) (nvml.BAR1Memory, nvml.Return) {
|
|
// panic("mock out the DeviceGetBAR1MemoryInfo method")
|
|
// },
|
|
// DeviceGetBoardIdFunc: func(device nvml.Device) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetBoardId method")
|
|
// },
|
|
// DeviceGetBoardPartNumberFunc: func(device nvml.Device) (string, nvml.Return) {
|
|
// panic("mock out the DeviceGetBoardPartNumber method")
|
|
// },
|
|
// DeviceGetBrandFunc: func(device nvml.Device) (nvml.BrandType, nvml.Return) {
|
|
// panic("mock out the DeviceGetBrand method")
|
|
// },
|
|
// DeviceGetBridgeChipInfoFunc: func(device nvml.Device) (nvml.BridgeChipHierarchy, nvml.Return) {
|
|
// panic("mock out the DeviceGetBridgeChipInfo method")
|
|
// },
|
|
// DeviceGetBusTypeFunc: func(device nvml.Device) (nvml.BusType, nvml.Return) {
|
|
// panic("mock out the DeviceGetBusType method")
|
|
// },
|
|
// DeviceGetClkMonStatusFunc: func(device nvml.Device) (nvml.ClkMonStatus, nvml.Return) {
|
|
// panic("mock out the DeviceGetClkMonStatus method")
|
|
// },
|
|
// DeviceGetClockFunc: func(device nvml.Device, clockType nvml.ClockType, clockId nvml.ClockId) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetClock method")
|
|
// },
|
|
// DeviceGetClockInfoFunc: func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetClockInfo method")
|
|
// },
|
|
// DeviceGetComputeInstanceIdFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetComputeInstanceId method")
|
|
// },
|
|
// DeviceGetComputeModeFunc: func(device nvml.Device) (nvml.ComputeMode, nvml.Return) {
|
|
// panic("mock out the DeviceGetComputeMode method")
|
|
// },
|
|
// DeviceGetComputeRunningProcessesFunc: func(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return) {
|
|
// panic("mock out the DeviceGetComputeRunningProcesses method")
|
|
// },
|
|
// DeviceGetCountFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetCount method")
|
|
// },
|
|
// DeviceGetCpuAffinityFunc: func(device nvml.Device, n int) ([]uint, nvml.Return) {
|
|
// panic("mock out the DeviceGetCpuAffinity method")
|
|
// },
|
|
// DeviceGetCpuAffinityWithinScopeFunc: func(device nvml.Device, n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return) {
|
|
// panic("mock out the DeviceGetCpuAffinityWithinScope method")
|
|
// },
|
|
// DeviceGetCreatableVgpusFunc: func(device nvml.Device) ([]nvml.VgpuTypeId, nvml.Return) {
|
|
// panic("mock out the DeviceGetCreatableVgpus method")
|
|
// },
|
|
// DeviceGetCudaComputeCapabilityFunc: func(device nvml.Device) (int, int, nvml.Return) {
|
|
// panic("mock out the DeviceGetCudaComputeCapability method")
|
|
// },
|
|
// DeviceGetCurrPcieLinkGenerationFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetCurrPcieLinkGeneration method")
|
|
// },
|
|
// DeviceGetCurrPcieLinkWidthFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetCurrPcieLinkWidth method")
|
|
// },
|
|
// DeviceGetCurrentClocksThrottleReasonsFunc: func(device nvml.Device) (uint64, nvml.Return) {
|
|
// panic("mock out the DeviceGetCurrentClocksThrottleReasons method")
|
|
// },
|
|
// DeviceGetDecoderUtilizationFunc: func(device nvml.Device) (uint32, uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetDecoderUtilization method")
|
|
// },
|
|
// DeviceGetDefaultApplicationsClockFunc: func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetDefaultApplicationsClock method")
|
|
// },
|
|
// DeviceGetDefaultEccModeFunc: func(device nvml.Device) (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the DeviceGetDefaultEccMode method")
|
|
// },
|
|
// DeviceGetDetailedEccErrorsFunc: func(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (nvml.EccErrorCounts, nvml.Return) {
|
|
// panic("mock out the DeviceGetDetailedEccErrors method")
|
|
// },
|
|
// DeviceGetDeviceHandleFromMigDeviceHandleFunc: func(device nvml.Device) (nvml.Device, nvml.Return) {
|
|
// panic("mock out the DeviceGetDeviceHandleFromMigDeviceHandle method")
|
|
// },
|
|
// DeviceGetDisplayActiveFunc: func(device nvml.Device) (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the DeviceGetDisplayActive method")
|
|
// },
|
|
// DeviceGetDisplayModeFunc: func(device nvml.Device) (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the DeviceGetDisplayMode method")
|
|
// },
|
|
// DeviceGetDriverModelFunc: func(device nvml.Device) (nvml.DriverModel, nvml.DriverModel, nvml.Return) {
|
|
// panic("mock out the DeviceGetDriverModel method")
|
|
// },
|
|
// DeviceGetDynamicPstatesInfoFunc: func(device nvml.Device) (nvml.GpuDynamicPstatesInfo, nvml.Return) {
|
|
// panic("mock out the DeviceGetDynamicPstatesInfo method")
|
|
// },
|
|
// DeviceGetEccModeFunc: func(device nvml.Device) (nvml.EnableState, nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the DeviceGetEccMode method")
|
|
// },
|
|
// DeviceGetEncoderCapacityFunc: func(device nvml.Device, encoderType nvml.EncoderType) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetEncoderCapacity method")
|
|
// },
|
|
// DeviceGetEncoderSessionsFunc: func(device nvml.Device) ([]nvml.EncoderSessionInfo, nvml.Return) {
|
|
// panic("mock out the DeviceGetEncoderSessions method")
|
|
// },
|
|
// DeviceGetEncoderStatsFunc: func(device nvml.Device) (int, uint32, uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetEncoderStats method")
|
|
// },
|
|
// DeviceGetEncoderUtilizationFunc: func(device nvml.Device) (uint32, uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetEncoderUtilization method")
|
|
// },
|
|
// DeviceGetEnforcedPowerLimitFunc: func(device nvml.Device) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetEnforcedPowerLimit method")
|
|
// },
|
|
// DeviceGetFBCSessionsFunc: func(device nvml.Device) ([]nvml.FBCSessionInfo, nvml.Return) {
|
|
// panic("mock out the DeviceGetFBCSessions method")
|
|
// },
|
|
// DeviceGetFBCStatsFunc: func(device nvml.Device) (nvml.FBCStats, nvml.Return) {
|
|
// panic("mock out the DeviceGetFBCStats method")
|
|
// },
|
|
// DeviceGetFanControlPolicy_v2Func: func(device nvml.Device, n int) (nvml.FanControlPolicy, nvml.Return) {
|
|
// panic("mock out the DeviceGetFanControlPolicy_v2 method")
|
|
// },
|
|
// DeviceGetFanSpeedFunc: func(device nvml.Device) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetFanSpeed method")
|
|
// },
|
|
// DeviceGetFanSpeed_v2Func: func(device nvml.Device, n int) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetFanSpeed_v2 method")
|
|
// },
|
|
// DeviceGetFieldValuesFunc: func(device nvml.Device, fieldValues []nvml.FieldValue) nvml.Return {
|
|
// panic("mock out the DeviceGetFieldValues method")
|
|
// },
|
|
// DeviceGetGpcClkMinMaxVfOffsetFunc: func(device nvml.Device) (int, int, nvml.Return) {
|
|
// panic("mock out the DeviceGetGpcClkMinMaxVfOffset method")
|
|
// },
|
|
// DeviceGetGpcClkVfOffsetFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetGpcClkVfOffset method")
|
|
// },
|
|
// DeviceGetGpuFabricInfoFunc: func(device nvml.Device) (nvml.GpuFabricInfo, nvml.Return) {
|
|
// panic("mock out the DeviceGetGpuFabricInfo method")
|
|
// },
|
|
// DeviceGetGpuInstanceByIdFunc: func(device nvml.Device, n int) (nvml.GpuInstance, nvml.Return) {
|
|
// panic("mock out the DeviceGetGpuInstanceById method")
|
|
// },
|
|
// DeviceGetGpuInstanceIdFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetGpuInstanceId method")
|
|
// },
|
|
// DeviceGetGpuInstancePossiblePlacementsFunc: func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstancePlacement, nvml.Return) {
|
|
// panic("mock out the DeviceGetGpuInstancePossiblePlacements method")
|
|
// },
|
|
// DeviceGetGpuInstanceProfileInfoFunc: func(device nvml.Device, n int) (nvml.GpuInstanceProfileInfo, nvml.Return) {
|
|
// panic("mock out the DeviceGetGpuInstanceProfileInfo method")
|
|
// },
|
|
// DeviceGetGpuInstanceProfileInfoVFunc: func(device nvml.Device, n int) nvml.GpuInstanceProfileInfoV {
|
|
// panic("mock out the DeviceGetGpuInstanceProfileInfoV method")
|
|
// },
|
|
// DeviceGetGpuInstanceRemainingCapacityFunc: func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetGpuInstanceRemainingCapacity method")
|
|
// },
|
|
// DeviceGetGpuInstancesFunc: func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstance, nvml.Return) {
|
|
// panic("mock out the DeviceGetGpuInstances method")
|
|
// },
|
|
// DeviceGetGpuMaxPcieLinkGenerationFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetGpuMaxPcieLinkGeneration method")
|
|
// },
|
|
// DeviceGetGpuOperationModeFunc: func(device nvml.Device) (nvml.GpuOperationMode, nvml.GpuOperationMode, nvml.Return) {
|
|
// panic("mock out the DeviceGetGpuOperationMode method")
|
|
// },
|
|
// DeviceGetGraphicsRunningProcessesFunc: func(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return) {
|
|
// panic("mock out the DeviceGetGraphicsRunningProcesses method")
|
|
// },
|
|
// DeviceGetGridLicensableFeaturesFunc: func(device nvml.Device) (nvml.GridLicensableFeatures, nvml.Return) {
|
|
// panic("mock out the DeviceGetGridLicensableFeatures method")
|
|
// },
|
|
// DeviceGetGspFirmwareModeFunc: func(device nvml.Device) (bool, bool, nvml.Return) {
|
|
// panic("mock out the DeviceGetGspFirmwareMode method")
|
|
// },
|
|
// DeviceGetGspFirmwareVersionFunc: func(device nvml.Device) (string, nvml.Return) {
|
|
// panic("mock out the DeviceGetGspFirmwareVersion method")
|
|
// },
|
|
// DeviceGetHandleByIndexFunc: func(n int) (nvml.Device, nvml.Return) {
|
|
// panic("mock out the DeviceGetHandleByIndex method")
|
|
// },
|
|
// DeviceGetHandleByPciBusIdFunc: func(s string) (nvml.Device, nvml.Return) {
|
|
// panic("mock out the DeviceGetHandleByPciBusId method")
|
|
// },
|
|
// DeviceGetHandleBySerialFunc: func(s string) (nvml.Device, nvml.Return) {
|
|
// panic("mock out the DeviceGetHandleBySerial method")
|
|
// },
|
|
// DeviceGetHandleByUUIDFunc: func(s string) (nvml.Device, nvml.Return) {
|
|
// panic("mock out the DeviceGetHandleByUUID method")
|
|
// },
|
|
// DeviceGetHostVgpuModeFunc: func(device nvml.Device) (nvml.HostVgpuMode, nvml.Return) {
|
|
// panic("mock out the DeviceGetHostVgpuMode method")
|
|
// },
|
|
// DeviceGetIndexFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetIndex method")
|
|
// },
|
|
// DeviceGetInforomConfigurationChecksumFunc: func(device nvml.Device) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetInforomConfigurationChecksum method")
|
|
// },
|
|
// DeviceGetInforomImageVersionFunc: func(device nvml.Device) (string, nvml.Return) {
|
|
// panic("mock out the DeviceGetInforomImageVersion method")
|
|
// },
|
|
// DeviceGetInforomVersionFunc: func(device nvml.Device, inforomObject nvml.InforomObject) (string, nvml.Return) {
|
|
// panic("mock out the DeviceGetInforomVersion method")
|
|
// },
|
|
// DeviceGetIrqNumFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetIrqNum method")
|
|
// },
|
|
// DeviceGetMPSComputeRunningProcessesFunc: func(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return) {
|
|
// panic("mock out the DeviceGetMPSComputeRunningProcesses method")
|
|
// },
|
|
// DeviceGetMaxClockInfoFunc: func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetMaxClockInfo method")
|
|
// },
|
|
// DeviceGetMaxCustomerBoostClockFunc: func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetMaxCustomerBoostClock method")
|
|
// },
|
|
// DeviceGetMaxMigDeviceCountFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetMaxMigDeviceCount method")
|
|
// },
|
|
// DeviceGetMaxPcieLinkGenerationFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetMaxPcieLinkGeneration method")
|
|
// },
|
|
// DeviceGetMaxPcieLinkWidthFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetMaxPcieLinkWidth method")
|
|
// },
|
|
// DeviceGetMemClkMinMaxVfOffsetFunc: func(device nvml.Device) (int, int, nvml.Return) {
|
|
// panic("mock out the DeviceGetMemClkMinMaxVfOffset method")
|
|
// },
|
|
// DeviceGetMemClkVfOffsetFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetMemClkVfOffset method")
|
|
// },
|
|
// DeviceGetMemoryAffinityFunc: func(device nvml.Device, n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return) {
|
|
// panic("mock out the DeviceGetMemoryAffinity method")
|
|
// },
|
|
// DeviceGetMemoryBusWidthFunc: func(device nvml.Device) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetMemoryBusWidth method")
|
|
// },
|
|
// DeviceGetMemoryErrorCounterFunc: func(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType, memoryLocation nvml.MemoryLocation) (uint64, nvml.Return) {
|
|
// panic("mock out the DeviceGetMemoryErrorCounter method")
|
|
// },
|
|
// DeviceGetMemoryInfoFunc: func(device nvml.Device) (nvml.Memory, nvml.Return) {
|
|
// panic("mock out the DeviceGetMemoryInfo method")
|
|
// },
|
|
// DeviceGetMemoryInfo_v2Func: func(device nvml.Device) (nvml.Memory_v2, nvml.Return) {
|
|
// panic("mock out the DeviceGetMemoryInfo_v2 method")
|
|
// },
|
|
// DeviceGetMigDeviceHandleByIndexFunc: func(device nvml.Device, n int) (nvml.Device, nvml.Return) {
|
|
// panic("mock out the DeviceGetMigDeviceHandleByIndex method")
|
|
// },
|
|
// DeviceGetMigModeFunc: func(device nvml.Device) (int, int, nvml.Return) {
|
|
// panic("mock out the DeviceGetMigMode method")
|
|
// },
|
|
// DeviceGetMinMaxClockOfPStateFunc: func(device nvml.Device, clockType nvml.ClockType, pstates nvml.Pstates) (uint32, uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetMinMaxClockOfPState method")
|
|
// },
|
|
// DeviceGetMinMaxFanSpeedFunc: func(device nvml.Device) (int, int, nvml.Return) {
|
|
// panic("mock out the DeviceGetMinMaxFanSpeed method")
|
|
// },
|
|
// DeviceGetMinorNumberFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetMinorNumber method")
|
|
// },
|
|
// DeviceGetMultiGpuBoardFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetMultiGpuBoard method")
|
|
// },
|
|
// DeviceGetNameFunc: func(device nvml.Device) (string, nvml.Return) {
|
|
// panic("mock out the DeviceGetName method")
|
|
// },
|
|
// DeviceGetNumFansFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetNumFans method")
|
|
// },
|
|
// DeviceGetNumGpuCoresFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetNumGpuCores method")
|
|
// },
|
|
// DeviceGetNvLinkCapabilityFunc: func(device nvml.Device, n int, nvLinkCapability nvml.NvLinkCapability) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetNvLinkCapability method")
|
|
// },
|
|
// DeviceGetNvLinkErrorCounterFunc: func(device nvml.Device, n int, nvLinkErrorCounter nvml.NvLinkErrorCounter) (uint64, nvml.Return) {
|
|
// panic("mock out the DeviceGetNvLinkErrorCounter method")
|
|
// },
|
|
// DeviceGetNvLinkRemoteDeviceTypeFunc: func(device nvml.Device, n int) (nvml.IntNvLinkDeviceType, nvml.Return) {
|
|
// panic("mock out the DeviceGetNvLinkRemoteDeviceType method")
|
|
// },
|
|
// DeviceGetNvLinkRemotePciInfoFunc: func(device nvml.Device, n int) (nvml.PciInfo, nvml.Return) {
|
|
// panic("mock out the DeviceGetNvLinkRemotePciInfo method")
|
|
// },
|
|
// DeviceGetNvLinkStateFunc: func(device nvml.Device, n int) (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the DeviceGetNvLinkState method")
|
|
// },
|
|
// DeviceGetNvLinkUtilizationControlFunc: func(device nvml.Device, n1 int, n2 int) (nvml.NvLinkUtilizationControl, nvml.Return) {
|
|
// panic("mock out the DeviceGetNvLinkUtilizationControl method")
|
|
// },
|
|
// DeviceGetNvLinkUtilizationCounterFunc: func(device nvml.Device, n1 int, n2 int) (uint64, uint64, nvml.Return) {
|
|
// panic("mock out the DeviceGetNvLinkUtilizationCounter method")
|
|
// },
|
|
// DeviceGetNvLinkVersionFunc: func(device nvml.Device, n int) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetNvLinkVersion method")
|
|
// },
|
|
// DeviceGetP2PStatusFunc: func(device1 nvml.Device, device2 nvml.Device, gpuP2PCapsIndex nvml.GpuP2PCapsIndex) (nvml.GpuP2PStatus, nvml.Return) {
|
|
// panic("mock out the DeviceGetP2PStatus method")
|
|
// },
|
|
// DeviceGetPciInfoFunc: func(device nvml.Device) (nvml.PciInfo, nvml.Return) {
|
|
// panic("mock out the DeviceGetPciInfo method")
|
|
// },
|
|
// DeviceGetPcieLinkMaxSpeedFunc: func(device nvml.Device) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetPcieLinkMaxSpeed method")
|
|
// },
|
|
// DeviceGetPcieReplayCounterFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetPcieReplayCounter method")
|
|
// },
|
|
// DeviceGetPcieSpeedFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetPcieSpeed method")
|
|
// },
|
|
// DeviceGetPcieThroughputFunc: func(device nvml.Device, pcieUtilCounter nvml.PcieUtilCounter) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetPcieThroughput method")
|
|
// },
|
|
// DeviceGetPerformanceStateFunc: func(device nvml.Device) (nvml.Pstates, nvml.Return) {
|
|
// panic("mock out the DeviceGetPerformanceState method")
|
|
// },
|
|
// DeviceGetPersistenceModeFunc: func(device nvml.Device) (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the DeviceGetPersistenceMode method")
|
|
// },
|
|
// DeviceGetPgpuMetadataStringFunc: func(device nvml.Device) (string, nvml.Return) {
|
|
// panic("mock out the DeviceGetPgpuMetadataString method")
|
|
// },
|
|
// DeviceGetPowerManagementDefaultLimitFunc: func(device nvml.Device) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetPowerManagementDefaultLimit method")
|
|
// },
|
|
// DeviceGetPowerManagementLimitFunc: func(device nvml.Device) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetPowerManagementLimit method")
|
|
// },
|
|
// DeviceGetPowerManagementLimitConstraintsFunc: func(device nvml.Device) (uint32, uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetPowerManagementLimitConstraints method")
|
|
// },
|
|
// DeviceGetPowerManagementModeFunc: func(device nvml.Device) (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the DeviceGetPowerManagementMode method")
|
|
// },
|
|
// DeviceGetPowerSourceFunc: func(device nvml.Device) (nvml.PowerSource, nvml.Return) {
|
|
// panic("mock out the DeviceGetPowerSource method")
|
|
// },
|
|
// DeviceGetPowerStateFunc: func(device nvml.Device) (nvml.Pstates, nvml.Return) {
|
|
// panic("mock out the DeviceGetPowerState method")
|
|
// },
|
|
// DeviceGetPowerUsageFunc: func(device nvml.Device) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetPowerUsage method")
|
|
// },
|
|
// DeviceGetProcessUtilizationFunc: func(device nvml.Device, v uint64) ([]nvml.ProcessUtilizationSample, nvml.Return) {
|
|
// panic("mock out the DeviceGetProcessUtilization method")
|
|
// },
|
|
// DeviceGetRemappedRowsFunc: func(device nvml.Device) (int, int, bool, bool, nvml.Return) {
|
|
// panic("mock out the DeviceGetRemappedRows method")
|
|
// },
|
|
// DeviceGetRetiredPagesFunc: func(device nvml.Device, pageRetirementCause nvml.PageRetirementCause) ([]uint64, nvml.Return) {
|
|
// panic("mock out the DeviceGetRetiredPages method")
|
|
// },
|
|
// DeviceGetRetiredPagesPendingStatusFunc: func(device nvml.Device) (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the DeviceGetRetiredPagesPendingStatus method")
|
|
// },
|
|
// DeviceGetRetiredPages_v2Func: func(device nvml.Device, pageRetirementCause nvml.PageRetirementCause) ([]uint64, []uint64, nvml.Return) {
|
|
// panic("mock out the DeviceGetRetiredPages_v2 method")
|
|
// },
|
|
// DeviceGetRowRemapperHistogramFunc: func(device nvml.Device) (nvml.RowRemapperHistogramValues, nvml.Return) {
|
|
// panic("mock out the DeviceGetRowRemapperHistogram method")
|
|
// },
|
|
// DeviceGetSamplesFunc: func(device nvml.Device, samplingType nvml.SamplingType, v uint64) (nvml.ValueType, []nvml.Sample, nvml.Return) {
|
|
// panic("mock out the DeviceGetSamples method")
|
|
// },
|
|
// DeviceGetSerialFunc: func(device nvml.Device) (string, nvml.Return) {
|
|
// panic("mock out the DeviceGetSerial method")
|
|
// },
|
|
// DeviceGetSupportedClocksThrottleReasonsFunc: func(device nvml.Device) (uint64, nvml.Return) {
|
|
// panic("mock out the DeviceGetSupportedClocksThrottleReasons method")
|
|
// },
|
|
// DeviceGetSupportedEventTypesFunc: func(device nvml.Device) (uint64, nvml.Return) {
|
|
// panic("mock out the DeviceGetSupportedEventTypes method")
|
|
// },
|
|
// DeviceGetSupportedGraphicsClocksFunc: func(device nvml.Device, n int) (int, uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetSupportedGraphicsClocks method")
|
|
// },
|
|
// DeviceGetSupportedMemoryClocksFunc: func(device nvml.Device) (int, uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetSupportedMemoryClocks method")
|
|
// },
|
|
// DeviceGetSupportedPerformanceStatesFunc: func(device nvml.Device) ([]nvml.Pstates, nvml.Return) {
|
|
// panic("mock out the DeviceGetSupportedPerformanceStates method")
|
|
// },
|
|
// DeviceGetSupportedVgpusFunc: func(device nvml.Device) ([]nvml.VgpuTypeId, nvml.Return) {
|
|
// panic("mock out the DeviceGetSupportedVgpus method")
|
|
// },
|
|
// DeviceGetTargetFanSpeedFunc: func(device nvml.Device, n int) (int, nvml.Return) {
|
|
// panic("mock out the DeviceGetTargetFanSpeed method")
|
|
// },
|
|
// DeviceGetTemperatureFunc: func(device nvml.Device, temperatureSensors nvml.TemperatureSensors) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetTemperature method")
|
|
// },
|
|
// DeviceGetTemperatureThresholdFunc: func(device nvml.Device, temperatureThresholds nvml.TemperatureThresholds) (uint32, nvml.Return) {
|
|
// panic("mock out the DeviceGetTemperatureThreshold method")
|
|
// },
|
|
// DeviceGetThermalSettingsFunc: func(device nvml.Device, v uint32) (nvml.GpuThermalSettings, nvml.Return) {
|
|
// panic("mock out the DeviceGetThermalSettings method")
|
|
// },
|
|
// DeviceGetTopologyCommonAncestorFunc: func(device1 nvml.Device, device2 nvml.Device) (nvml.GpuTopologyLevel, nvml.Return) {
|
|
// panic("mock out the DeviceGetTopologyCommonAncestor method")
|
|
// },
|
|
// DeviceGetTopologyNearestGpusFunc: func(device nvml.Device, gpuTopologyLevel nvml.GpuTopologyLevel) ([]nvml.Device, nvml.Return) {
|
|
// panic("mock out the DeviceGetTopologyNearestGpus method")
|
|
// },
|
|
// DeviceGetTotalEccErrorsFunc: func(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (uint64, nvml.Return) {
|
|
// panic("mock out the DeviceGetTotalEccErrors method")
|
|
// },
|
|
// DeviceGetTotalEnergyConsumptionFunc: func(device nvml.Device) (uint64, nvml.Return) {
|
|
// panic("mock out the DeviceGetTotalEnergyConsumption method")
|
|
// },
|
|
// DeviceGetUUIDFunc: func(device nvml.Device) (string, nvml.Return) {
|
|
// panic("mock out the DeviceGetUUID method")
|
|
// },
|
|
// DeviceGetUtilizationRatesFunc: func(device nvml.Device) (nvml.Utilization, nvml.Return) {
|
|
// panic("mock out the DeviceGetUtilizationRates method")
|
|
// },
|
|
// DeviceGetVbiosVersionFunc: func(device nvml.Device) (string, nvml.Return) {
|
|
// panic("mock out the DeviceGetVbiosVersion method")
|
|
// },
|
|
// DeviceGetVgpuCapabilitiesFunc: func(device nvml.Device, deviceVgpuCapability nvml.DeviceVgpuCapability) (bool, nvml.Return) {
|
|
// panic("mock out the DeviceGetVgpuCapabilities method")
|
|
// },
|
|
// DeviceGetVgpuMetadataFunc: func(device nvml.Device) (nvml.VgpuPgpuMetadata, nvml.Return) {
|
|
// panic("mock out the DeviceGetVgpuMetadata method")
|
|
// },
|
|
// DeviceGetVgpuProcessUtilizationFunc: func(device nvml.Device, v uint64) ([]nvml.VgpuProcessUtilizationSample, nvml.Return) {
|
|
// panic("mock out the DeviceGetVgpuProcessUtilization method")
|
|
// },
|
|
// DeviceGetVgpuSchedulerCapabilitiesFunc: func(device nvml.Device) (nvml.VgpuSchedulerCapabilities, nvml.Return) {
|
|
// panic("mock out the DeviceGetVgpuSchedulerCapabilities method")
|
|
// },
|
|
// DeviceGetVgpuSchedulerLogFunc: func(device nvml.Device) (nvml.VgpuSchedulerLog, nvml.Return) {
|
|
// panic("mock out the DeviceGetVgpuSchedulerLog method")
|
|
// },
|
|
// DeviceGetVgpuSchedulerStateFunc: func(device nvml.Device) (nvml.VgpuSchedulerGetState, nvml.Return) {
|
|
// panic("mock out the DeviceGetVgpuSchedulerState method")
|
|
// },
|
|
// DeviceGetVgpuUtilizationFunc: func(device nvml.Device, v uint64) (nvml.ValueType, []nvml.VgpuInstanceUtilizationSample, nvml.Return) {
|
|
// panic("mock out the DeviceGetVgpuUtilization method")
|
|
// },
|
|
// DeviceGetViolationStatusFunc: func(device nvml.Device, perfPolicyType nvml.PerfPolicyType) (nvml.ViolationTime, nvml.Return) {
|
|
// panic("mock out the DeviceGetViolationStatus method")
|
|
// },
|
|
// DeviceGetVirtualizationModeFunc: func(device nvml.Device) (nvml.GpuVirtualizationMode, nvml.Return) {
|
|
// panic("mock out the DeviceGetVirtualizationMode method")
|
|
// },
|
|
// DeviceIsMigDeviceHandleFunc: func(device nvml.Device) (bool, nvml.Return) {
|
|
// panic("mock out the DeviceIsMigDeviceHandle method")
|
|
// },
|
|
// DeviceModifyDrainStateFunc: func(pciInfo *nvml.PciInfo, enableState nvml.EnableState) nvml.Return {
|
|
// panic("mock out the DeviceModifyDrainState method")
|
|
// },
|
|
// DeviceOnSameBoardFunc: func(device1 nvml.Device, device2 nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the DeviceOnSameBoard method")
|
|
// },
|
|
// DeviceQueryDrainStateFunc: func(pciInfo *nvml.PciInfo) (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the DeviceQueryDrainState method")
|
|
// },
|
|
// DeviceRegisterEventsFunc: func(device nvml.Device, v uint64, eventSet nvml.EventSet) nvml.Return {
|
|
// panic("mock out the DeviceRegisterEvents method")
|
|
// },
|
|
// DeviceRemoveGpuFunc: func(pciInfo *nvml.PciInfo) nvml.Return {
|
|
// panic("mock out the DeviceRemoveGpu method")
|
|
// },
|
|
// DeviceRemoveGpu_v2Func: func(pciInfo *nvml.PciInfo, detachGpuState nvml.DetachGpuState, pcieLinkState nvml.PcieLinkState) nvml.Return {
|
|
// panic("mock out the DeviceRemoveGpu_v2 method")
|
|
// },
|
|
// DeviceResetApplicationsClocksFunc: func(device nvml.Device) nvml.Return {
|
|
// panic("mock out the DeviceResetApplicationsClocks method")
|
|
// },
|
|
// DeviceResetGpuLockedClocksFunc: func(device nvml.Device) nvml.Return {
|
|
// panic("mock out the DeviceResetGpuLockedClocks method")
|
|
// },
|
|
// DeviceResetMemoryLockedClocksFunc: func(device nvml.Device) nvml.Return {
|
|
// panic("mock out the DeviceResetMemoryLockedClocks method")
|
|
// },
|
|
// DeviceResetNvLinkErrorCountersFunc: func(device nvml.Device, n int) nvml.Return {
|
|
// panic("mock out the DeviceResetNvLinkErrorCounters method")
|
|
// },
|
|
// DeviceResetNvLinkUtilizationCounterFunc: func(device nvml.Device, n1 int, n2 int) nvml.Return {
|
|
// panic("mock out the DeviceResetNvLinkUtilizationCounter method")
|
|
// },
|
|
// DeviceSetAPIRestrictionFunc: func(device nvml.Device, restrictedAPI nvml.RestrictedAPI, enableState nvml.EnableState) nvml.Return {
|
|
// panic("mock out the DeviceSetAPIRestriction method")
|
|
// },
|
|
// DeviceSetAccountingModeFunc: func(device nvml.Device, enableState nvml.EnableState) nvml.Return {
|
|
// panic("mock out the DeviceSetAccountingMode method")
|
|
// },
|
|
// DeviceSetApplicationsClocksFunc: func(device nvml.Device, v1 uint32, v2 uint32) nvml.Return {
|
|
// panic("mock out the DeviceSetApplicationsClocks method")
|
|
// },
|
|
// DeviceSetAutoBoostedClocksEnabledFunc: func(device nvml.Device, enableState nvml.EnableState) nvml.Return {
|
|
// panic("mock out the DeviceSetAutoBoostedClocksEnabled method")
|
|
// },
|
|
// DeviceSetComputeModeFunc: func(device nvml.Device, computeMode nvml.ComputeMode) nvml.Return {
|
|
// panic("mock out the DeviceSetComputeMode method")
|
|
// },
|
|
// DeviceSetCpuAffinityFunc: func(device nvml.Device) nvml.Return {
|
|
// panic("mock out the DeviceSetCpuAffinity method")
|
|
// },
|
|
// DeviceSetDefaultAutoBoostedClocksEnabledFunc: func(device nvml.Device, enableState nvml.EnableState, v uint32) nvml.Return {
|
|
// panic("mock out the DeviceSetDefaultAutoBoostedClocksEnabled method")
|
|
// },
|
|
// DeviceSetDefaultFanSpeed_v2Func: func(device nvml.Device, n int) nvml.Return {
|
|
// panic("mock out the DeviceSetDefaultFanSpeed_v2 method")
|
|
// },
|
|
// DeviceSetDriverModelFunc: func(device nvml.Device, driverModel nvml.DriverModel, v uint32) nvml.Return {
|
|
// panic("mock out the DeviceSetDriverModel method")
|
|
// },
|
|
// DeviceSetEccModeFunc: func(device nvml.Device, enableState nvml.EnableState) nvml.Return {
|
|
// panic("mock out the DeviceSetEccMode method")
|
|
// },
|
|
// DeviceSetFanControlPolicyFunc: func(device nvml.Device, n int, fanControlPolicy nvml.FanControlPolicy) nvml.Return {
|
|
// panic("mock out the DeviceSetFanControlPolicy method")
|
|
// },
|
|
// DeviceSetFanSpeed_v2Func: func(device nvml.Device, n1 int, n2 int) nvml.Return {
|
|
// panic("mock out the DeviceSetFanSpeed_v2 method")
|
|
// },
|
|
// DeviceSetGpcClkVfOffsetFunc: func(device nvml.Device, n int) nvml.Return {
|
|
// panic("mock out the DeviceSetGpcClkVfOffset method")
|
|
// },
|
|
// DeviceSetGpuLockedClocksFunc: func(device nvml.Device, v1 uint32, v2 uint32) nvml.Return {
|
|
// panic("mock out the DeviceSetGpuLockedClocks method")
|
|
// },
|
|
// DeviceSetGpuOperationModeFunc: func(device nvml.Device, gpuOperationMode nvml.GpuOperationMode) nvml.Return {
|
|
// panic("mock out the DeviceSetGpuOperationMode method")
|
|
// },
|
|
// DeviceSetMemClkVfOffsetFunc: func(device nvml.Device, n int) nvml.Return {
|
|
// panic("mock out the DeviceSetMemClkVfOffset method")
|
|
// },
|
|
// DeviceSetMemoryLockedClocksFunc: func(device nvml.Device, v1 uint32, v2 uint32) nvml.Return {
|
|
// panic("mock out the DeviceSetMemoryLockedClocks method")
|
|
// },
|
|
// DeviceSetMigModeFunc: func(device nvml.Device, n int) (nvml.Return, nvml.Return) {
|
|
// panic("mock out the DeviceSetMigMode method")
|
|
// },
|
|
// DeviceSetNvLinkDeviceLowPowerThresholdFunc: func(device nvml.Device, nvLinkPowerThres *nvml.NvLinkPowerThres) nvml.Return {
|
|
// panic("mock out the DeviceSetNvLinkDeviceLowPowerThreshold method")
|
|
// },
|
|
// DeviceSetNvLinkUtilizationControlFunc: func(device nvml.Device, n1 int, n2 int, nvLinkUtilizationControl *nvml.NvLinkUtilizationControl, b bool) nvml.Return {
|
|
// panic("mock out the DeviceSetNvLinkUtilizationControl method")
|
|
// },
|
|
// DeviceSetPersistenceModeFunc: func(device nvml.Device, enableState nvml.EnableState) nvml.Return {
|
|
// panic("mock out the DeviceSetPersistenceMode method")
|
|
// },
|
|
// DeviceSetPowerManagementLimitFunc: func(device nvml.Device, v uint32) nvml.Return {
|
|
// panic("mock out the DeviceSetPowerManagementLimit method")
|
|
// },
|
|
// DeviceSetTemperatureThresholdFunc: func(device nvml.Device, temperatureThresholds nvml.TemperatureThresholds, n int) nvml.Return {
|
|
// panic("mock out the DeviceSetTemperatureThreshold method")
|
|
// },
|
|
// DeviceSetVgpuSchedulerStateFunc: func(device nvml.Device, vgpuSchedulerSetState *nvml.VgpuSchedulerSetState) nvml.Return {
|
|
// panic("mock out the DeviceSetVgpuSchedulerState method")
|
|
// },
|
|
// DeviceSetVirtualizationModeFunc: func(device nvml.Device, gpuVirtualizationMode nvml.GpuVirtualizationMode) nvml.Return {
|
|
// panic("mock out the DeviceSetVirtualizationMode method")
|
|
// },
|
|
// DeviceValidateInforomFunc: func(device nvml.Device) nvml.Return {
|
|
// panic("mock out the DeviceValidateInforom method")
|
|
// },
|
|
// ErrorStringFunc: func(returnMoqParam nvml.Return) string {
|
|
// panic("mock out the ErrorString method")
|
|
// },
|
|
// EventSetCreateFunc: func() (nvml.EventSet, nvml.Return) {
|
|
// panic("mock out the EventSetCreate method")
|
|
// },
|
|
// EventSetFreeFunc: func(eventSet nvml.EventSet) nvml.Return {
|
|
// panic("mock out the EventSetFree method")
|
|
// },
|
|
// EventSetWaitFunc: func(eventSet nvml.EventSet, v uint32) (nvml.EventData, nvml.Return) {
|
|
// panic("mock out the EventSetWait method")
|
|
// },
|
|
// ExtensionsFunc: func() nvml.ExtendedInterface {
|
|
// panic("mock out the Extensions method")
|
|
// },
|
|
// GetExcludedDeviceCountFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetExcludedDeviceCount method")
|
|
// },
|
|
// GetExcludedDeviceInfoByIndexFunc: func(n int) (nvml.ExcludedDeviceInfo, nvml.Return) {
|
|
// panic("mock out the GetExcludedDeviceInfoByIndex method")
|
|
// },
|
|
// GetVgpuCompatibilityFunc: func(vgpuMetadata *nvml.VgpuMetadata, vgpuPgpuMetadata *nvml.VgpuPgpuMetadata) (nvml.VgpuPgpuCompatibility, nvml.Return) {
|
|
// panic("mock out the GetVgpuCompatibility method")
|
|
// },
|
|
// GetVgpuDriverCapabilitiesFunc: func(vgpuDriverCapability nvml.VgpuDriverCapability) (bool, nvml.Return) {
|
|
// panic("mock out the GetVgpuDriverCapabilities method")
|
|
// },
|
|
// GetVgpuVersionFunc: func() (nvml.VgpuVersion, nvml.VgpuVersion, nvml.Return) {
|
|
// panic("mock out the GetVgpuVersion method")
|
|
// },
|
|
// GpmMetricsGetFunc: func(gpmMetricsGetType *nvml.GpmMetricsGetType) nvml.Return {
|
|
// panic("mock out the GpmMetricsGet method")
|
|
// },
|
|
// GpmMetricsGetVFunc: func(gpmMetricsGetType *nvml.GpmMetricsGetType) nvml.GpmMetricsGetVType {
|
|
// panic("mock out the GpmMetricsGetV method")
|
|
// },
|
|
// GpmMigSampleGetFunc: func(device nvml.Device, n int, gpmSample nvml.GpmSample) nvml.Return {
|
|
// panic("mock out the GpmMigSampleGet method")
|
|
// },
|
|
// GpmQueryDeviceSupportFunc: func(device nvml.Device) (nvml.GpmSupport, nvml.Return) {
|
|
// panic("mock out the GpmQueryDeviceSupport method")
|
|
// },
|
|
// GpmQueryDeviceSupportVFunc: func(device nvml.Device) nvml.GpmSupportV {
|
|
// panic("mock out the GpmQueryDeviceSupportV method")
|
|
// },
|
|
// GpmSampleAllocFunc: func() (nvml.GpmSample, nvml.Return) {
|
|
// panic("mock out the GpmSampleAlloc method")
|
|
// },
|
|
// GpmSampleFreeFunc: func(gpmSample nvml.GpmSample) nvml.Return {
|
|
// panic("mock out the GpmSampleFree method")
|
|
// },
|
|
// GpmSampleGetFunc: func(device nvml.Device, gpmSample nvml.GpmSample) nvml.Return {
|
|
// panic("mock out the GpmSampleGet method")
|
|
// },
|
|
// GpuInstanceCreateComputeInstanceFunc: func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) (nvml.ComputeInstance, nvml.Return) {
|
|
// panic("mock out the GpuInstanceCreateComputeInstance method")
|
|
// },
|
|
// GpuInstanceCreateComputeInstanceWithPlacementFunc: func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo, computeInstancePlacement *nvml.ComputeInstancePlacement) (nvml.ComputeInstance, nvml.Return) {
|
|
// panic("mock out the GpuInstanceCreateComputeInstanceWithPlacement method")
|
|
// },
|
|
// GpuInstanceDestroyFunc: func(gpuInstance nvml.GpuInstance) nvml.Return {
|
|
// panic("mock out the GpuInstanceDestroy method")
|
|
// },
|
|
// GpuInstanceGetComputeInstanceByIdFunc: func(gpuInstance nvml.GpuInstance, n int) (nvml.ComputeInstance, nvml.Return) {
|
|
// panic("mock out the GpuInstanceGetComputeInstanceById method")
|
|
// },
|
|
// GpuInstanceGetComputeInstancePossiblePlacementsFunc: func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) ([]nvml.ComputeInstancePlacement, nvml.Return) {
|
|
// panic("mock out the GpuInstanceGetComputeInstancePossiblePlacements method")
|
|
// },
|
|
// GpuInstanceGetComputeInstanceProfileInfoFunc: func(gpuInstance nvml.GpuInstance, n1 int, n2 int) (nvml.ComputeInstanceProfileInfo, nvml.Return) {
|
|
// panic("mock out the GpuInstanceGetComputeInstanceProfileInfo method")
|
|
// },
|
|
// GpuInstanceGetComputeInstanceProfileInfoVFunc: func(gpuInstance nvml.GpuInstance, n1 int, n2 int) nvml.ComputeInstanceProfileInfoV {
|
|
// panic("mock out the GpuInstanceGetComputeInstanceProfileInfoV method")
|
|
// },
|
|
// GpuInstanceGetComputeInstanceRemainingCapacityFunc: func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) (int, nvml.Return) {
|
|
// panic("mock out the GpuInstanceGetComputeInstanceRemainingCapacity method")
|
|
// },
|
|
// GpuInstanceGetComputeInstancesFunc: func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) ([]nvml.ComputeInstance, nvml.Return) {
|
|
// panic("mock out the GpuInstanceGetComputeInstances method")
|
|
// },
|
|
// GpuInstanceGetInfoFunc: func(gpuInstance nvml.GpuInstance) (nvml.GpuInstanceInfo, nvml.Return) {
|
|
// panic("mock out the GpuInstanceGetInfo method")
|
|
// },
|
|
// InitFunc: func() nvml.Return {
|
|
// panic("mock out the Init method")
|
|
// },
|
|
// InitWithFlagsFunc: func(v uint32) nvml.Return {
|
|
// panic("mock out the InitWithFlags method")
|
|
// },
|
|
// SetVgpuVersionFunc: func(vgpuVersion *nvml.VgpuVersion) nvml.Return {
|
|
// panic("mock out the SetVgpuVersion method")
|
|
// },
|
|
// ShutdownFunc: func() nvml.Return {
|
|
// panic("mock out the Shutdown method")
|
|
// },
|
|
// SystemGetCudaDriverVersionFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the SystemGetCudaDriverVersion method")
|
|
// },
|
|
// SystemGetCudaDriverVersion_v2Func: func() (int, nvml.Return) {
|
|
// panic("mock out the SystemGetCudaDriverVersion_v2 method")
|
|
// },
|
|
// SystemGetDriverVersionFunc: func() (string, nvml.Return) {
|
|
// panic("mock out the SystemGetDriverVersion method")
|
|
// },
|
|
// SystemGetHicVersionFunc: func() ([]nvml.HwbcEntry, nvml.Return) {
|
|
// panic("mock out the SystemGetHicVersion method")
|
|
// },
|
|
// SystemGetNVMLVersionFunc: func() (string, nvml.Return) {
|
|
// panic("mock out the SystemGetNVMLVersion method")
|
|
// },
|
|
// SystemGetProcessNameFunc: func(n int) (string, nvml.Return) {
|
|
// panic("mock out the SystemGetProcessName method")
|
|
// },
|
|
// SystemGetTopologyGpuSetFunc: func(n int) ([]nvml.Device, nvml.Return) {
|
|
// panic("mock out the SystemGetTopologyGpuSet method")
|
|
// },
|
|
// UnitGetCountFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the UnitGetCount method")
|
|
// },
|
|
// UnitGetDevicesFunc: func(unit nvml.Unit) ([]nvml.Device, nvml.Return) {
|
|
// panic("mock out the UnitGetDevices method")
|
|
// },
|
|
// UnitGetFanSpeedInfoFunc: func(unit nvml.Unit) (nvml.UnitFanSpeeds, nvml.Return) {
|
|
// panic("mock out the UnitGetFanSpeedInfo method")
|
|
// },
|
|
// UnitGetHandleByIndexFunc: func(n int) (nvml.Unit, nvml.Return) {
|
|
// panic("mock out the UnitGetHandleByIndex method")
|
|
// },
|
|
// UnitGetLedStateFunc: func(unit nvml.Unit) (nvml.LedState, nvml.Return) {
|
|
// panic("mock out the UnitGetLedState method")
|
|
// },
|
|
// UnitGetPsuInfoFunc: func(unit nvml.Unit) (nvml.PSUInfo, nvml.Return) {
|
|
// panic("mock out the UnitGetPsuInfo method")
|
|
// },
|
|
// UnitGetTemperatureFunc: func(unit nvml.Unit, n int) (uint32, nvml.Return) {
|
|
// panic("mock out the UnitGetTemperature method")
|
|
// },
|
|
// UnitGetUnitInfoFunc: func(unit nvml.Unit) (nvml.UnitInfo, nvml.Return) {
|
|
// panic("mock out the UnitGetUnitInfo method")
|
|
// },
|
|
// UnitSetLedStateFunc: func(unit nvml.Unit, ledColor nvml.LedColor) nvml.Return {
|
|
// panic("mock out the UnitSetLedState method")
|
|
// },
|
|
// VgpuInstanceClearAccountingPidsFunc: func(vgpuInstance nvml.VgpuInstance) nvml.Return {
|
|
// panic("mock out the VgpuInstanceClearAccountingPids method")
|
|
// },
|
|
// VgpuInstanceGetAccountingModeFunc: func(vgpuInstance nvml.VgpuInstance) (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetAccountingMode method")
|
|
// },
|
|
// VgpuInstanceGetAccountingPidsFunc: func(vgpuInstance nvml.VgpuInstance) ([]int, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetAccountingPids method")
|
|
// },
|
|
// VgpuInstanceGetAccountingStatsFunc: func(vgpuInstance nvml.VgpuInstance, n int) (nvml.AccountingStats, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetAccountingStats method")
|
|
// },
|
|
// VgpuInstanceGetEccModeFunc: func(vgpuInstance nvml.VgpuInstance) (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetEccMode method")
|
|
// },
|
|
// VgpuInstanceGetEncoderCapacityFunc: func(vgpuInstance nvml.VgpuInstance) (int, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetEncoderCapacity method")
|
|
// },
|
|
// VgpuInstanceGetEncoderSessionsFunc: func(vgpuInstance nvml.VgpuInstance) (int, nvml.EncoderSessionInfo, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetEncoderSessions method")
|
|
// },
|
|
// VgpuInstanceGetEncoderStatsFunc: func(vgpuInstance nvml.VgpuInstance) (int, uint32, uint32, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetEncoderStats method")
|
|
// },
|
|
// VgpuInstanceGetFBCSessionsFunc: func(vgpuInstance nvml.VgpuInstance) (int, nvml.FBCSessionInfo, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetFBCSessions method")
|
|
// },
|
|
// VgpuInstanceGetFBCStatsFunc: func(vgpuInstance nvml.VgpuInstance) (nvml.FBCStats, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetFBCStats method")
|
|
// },
|
|
// VgpuInstanceGetFbUsageFunc: func(vgpuInstance nvml.VgpuInstance) (uint64, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetFbUsage method")
|
|
// },
|
|
// VgpuInstanceGetFrameRateLimitFunc: func(vgpuInstance nvml.VgpuInstance) (uint32, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetFrameRateLimit method")
|
|
// },
|
|
// VgpuInstanceGetGpuInstanceIdFunc: func(vgpuInstance nvml.VgpuInstance) (int, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetGpuInstanceId method")
|
|
// },
|
|
// VgpuInstanceGetGpuPciIdFunc: func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetGpuPciId method")
|
|
// },
|
|
// VgpuInstanceGetLicenseInfoFunc: func(vgpuInstance nvml.VgpuInstance) (nvml.VgpuLicenseInfo, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetLicenseInfo method")
|
|
// },
|
|
// VgpuInstanceGetLicenseStatusFunc: func(vgpuInstance nvml.VgpuInstance) (int, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetLicenseStatus method")
|
|
// },
|
|
// VgpuInstanceGetMdevUUIDFunc: func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetMdevUUID method")
|
|
// },
|
|
// VgpuInstanceGetMetadataFunc: func(vgpuInstance nvml.VgpuInstance) (nvml.VgpuMetadata, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetMetadata method")
|
|
// },
|
|
// VgpuInstanceGetTypeFunc: func(vgpuInstance nvml.VgpuInstance) (nvml.VgpuTypeId, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetType method")
|
|
// },
|
|
// VgpuInstanceGetUUIDFunc: func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetUUID method")
|
|
// },
|
|
// VgpuInstanceGetVmDriverVersionFunc: func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetVmDriverVersion method")
|
|
// },
|
|
// VgpuInstanceGetVmIDFunc: func(vgpuInstance nvml.VgpuInstance) (string, nvml.VgpuVmIdType, nvml.Return) {
|
|
// panic("mock out the VgpuInstanceGetVmID method")
|
|
// },
|
|
// VgpuInstanceSetEncoderCapacityFunc: func(vgpuInstance nvml.VgpuInstance, n int) nvml.Return {
|
|
// panic("mock out the VgpuInstanceSetEncoderCapacity method")
|
|
// },
|
|
// VgpuTypeGetCapabilitiesFunc: func(vgpuTypeId nvml.VgpuTypeId, vgpuCapability nvml.VgpuCapability) (bool, nvml.Return) {
|
|
// panic("mock out the VgpuTypeGetCapabilities method")
|
|
// },
|
|
// VgpuTypeGetClassFunc: func(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return) {
|
|
// panic("mock out the VgpuTypeGetClass method")
|
|
// },
|
|
// VgpuTypeGetDeviceIDFunc: func(vgpuTypeId nvml.VgpuTypeId) (uint64, uint64, nvml.Return) {
|
|
// panic("mock out the VgpuTypeGetDeviceID method")
|
|
// },
|
|
// VgpuTypeGetFrameRateLimitFunc: func(vgpuTypeId nvml.VgpuTypeId) (uint32, nvml.Return) {
|
|
// panic("mock out the VgpuTypeGetFrameRateLimit method")
|
|
// },
|
|
// VgpuTypeGetFramebufferSizeFunc: func(vgpuTypeId nvml.VgpuTypeId) (uint64, nvml.Return) {
|
|
// panic("mock out the VgpuTypeGetFramebufferSize method")
|
|
// },
|
|
// VgpuTypeGetGpuInstanceProfileIdFunc: func(vgpuTypeId nvml.VgpuTypeId) (uint32, nvml.Return) {
|
|
// panic("mock out the VgpuTypeGetGpuInstanceProfileId method")
|
|
// },
|
|
// VgpuTypeGetLicenseFunc: func(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return) {
|
|
// panic("mock out the VgpuTypeGetLicense method")
|
|
// },
|
|
// VgpuTypeGetMaxInstancesFunc: func(device nvml.Device, vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
|
|
// panic("mock out the VgpuTypeGetMaxInstances method")
|
|
// },
|
|
// VgpuTypeGetMaxInstancesPerVmFunc: func(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
|
|
// panic("mock out the VgpuTypeGetMaxInstancesPerVm method")
|
|
// },
|
|
// VgpuTypeGetNameFunc: func(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return) {
|
|
// panic("mock out the VgpuTypeGetName method")
|
|
// },
|
|
// VgpuTypeGetNumDisplayHeadsFunc: func(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
|
|
// panic("mock out the VgpuTypeGetNumDisplayHeads method")
|
|
// },
|
|
// VgpuTypeGetResolutionFunc: func(vgpuTypeId nvml.VgpuTypeId, n int) (uint32, uint32, nvml.Return) {
|
|
// panic("mock out the VgpuTypeGetResolution method")
|
|
// },
|
|
// }
|
|
//
|
|
// // use mockedInterface in code that requires nvml.Interface
|
|
// // and then make assertions.
|
|
//
|
|
// }
|
|
type Interface struct {
|
|
// ComputeInstanceDestroyFunc mocks the ComputeInstanceDestroy method.
|
|
ComputeInstanceDestroyFunc func(computeInstance nvml.ComputeInstance) nvml.Return
|
|
|
|
// ComputeInstanceGetInfoFunc mocks the ComputeInstanceGetInfo method.
|
|
ComputeInstanceGetInfoFunc func(computeInstance nvml.ComputeInstance) (nvml.ComputeInstanceInfo, nvml.Return)
|
|
|
|
// DeviceCcuGetStreamStateFunc mocks the DeviceCcuGetStreamState method.
|
|
DeviceCcuGetStreamStateFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceCcuSetStreamStateFunc mocks the DeviceCcuSetStreamState method.
|
|
DeviceCcuSetStreamStateFunc func(device nvml.Device, n int) nvml.Return
|
|
|
|
// DeviceClearAccountingPidsFunc mocks the DeviceClearAccountingPids method.
|
|
DeviceClearAccountingPidsFunc func(device nvml.Device) nvml.Return
|
|
|
|
// DeviceClearCpuAffinityFunc mocks the DeviceClearCpuAffinity method.
|
|
DeviceClearCpuAffinityFunc func(device nvml.Device) nvml.Return
|
|
|
|
// DeviceClearEccErrorCountsFunc mocks the DeviceClearEccErrorCounts method.
|
|
DeviceClearEccErrorCountsFunc func(device nvml.Device, eccCounterType nvml.EccCounterType) nvml.Return
|
|
|
|
// DeviceClearFieldValuesFunc mocks the DeviceClearFieldValues method.
|
|
DeviceClearFieldValuesFunc func(device nvml.Device, fieldValues []nvml.FieldValue) nvml.Return
|
|
|
|
// DeviceCreateGpuInstanceFunc mocks the DeviceCreateGpuInstance method.
|
|
DeviceCreateGpuInstanceFunc func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (nvml.GpuInstance, nvml.Return)
|
|
|
|
// DeviceCreateGpuInstanceWithPlacementFunc mocks the DeviceCreateGpuInstanceWithPlacement method.
|
|
DeviceCreateGpuInstanceWithPlacementFunc func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo, gpuInstancePlacement *nvml.GpuInstancePlacement) (nvml.GpuInstance, nvml.Return)
|
|
|
|
// DeviceDiscoverGpusFunc mocks the DeviceDiscoverGpus method.
|
|
DeviceDiscoverGpusFunc func() (nvml.PciInfo, nvml.Return)
|
|
|
|
// DeviceFreezeNvLinkUtilizationCounterFunc mocks the DeviceFreezeNvLinkUtilizationCounter method.
|
|
DeviceFreezeNvLinkUtilizationCounterFunc func(device nvml.Device, n1 int, n2 int, enableState nvml.EnableState) nvml.Return
|
|
|
|
// DeviceGetAPIRestrictionFunc mocks the DeviceGetAPIRestriction method.
|
|
DeviceGetAPIRestrictionFunc func(device nvml.Device, restrictedAPI nvml.RestrictedAPI) (nvml.EnableState, nvml.Return)
|
|
|
|
// DeviceGetAccountingBufferSizeFunc mocks the DeviceGetAccountingBufferSize method.
|
|
DeviceGetAccountingBufferSizeFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetAccountingModeFunc mocks the DeviceGetAccountingMode method.
|
|
DeviceGetAccountingModeFunc func(device nvml.Device) (nvml.EnableState, nvml.Return)
|
|
|
|
// DeviceGetAccountingPidsFunc mocks the DeviceGetAccountingPids method.
|
|
DeviceGetAccountingPidsFunc func(device nvml.Device) ([]int, nvml.Return)
|
|
|
|
// DeviceGetAccountingStatsFunc mocks the DeviceGetAccountingStats method.
|
|
DeviceGetAccountingStatsFunc func(device nvml.Device, v uint32) (nvml.AccountingStats, nvml.Return)
|
|
|
|
// DeviceGetActiveVgpusFunc mocks the DeviceGetActiveVgpus method.
|
|
DeviceGetActiveVgpusFunc func(device nvml.Device) ([]nvml.VgpuInstance, nvml.Return)
|
|
|
|
// DeviceGetAdaptiveClockInfoStatusFunc mocks the DeviceGetAdaptiveClockInfoStatus method.
|
|
DeviceGetAdaptiveClockInfoStatusFunc func(device nvml.Device) (uint32, nvml.Return)
|
|
|
|
// DeviceGetApplicationsClockFunc mocks the DeviceGetApplicationsClock method.
|
|
DeviceGetApplicationsClockFunc func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return)
|
|
|
|
// DeviceGetArchitectureFunc mocks the DeviceGetArchitecture method.
|
|
DeviceGetArchitectureFunc func(device nvml.Device) (nvml.DeviceArchitecture, nvml.Return)
|
|
|
|
// DeviceGetAttributesFunc mocks the DeviceGetAttributes method.
|
|
DeviceGetAttributesFunc func(device nvml.Device) (nvml.DeviceAttributes, nvml.Return)
|
|
|
|
// DeviceGetAutoBoostedClocksEnabledFunc mocks the DeviceGetAutoBoostedClocksEnabled method.
|
|
DeviceGetAutoBoostedClocksEnabledFunc func(device nvml.Device) (nvml.EnableState, nvml.EnableState, nvml.Return)
|
|
|
|
// DeviceGetBAR1MemoryInfoFunc mocks the DeviceGetBAR1MemoryInfo method.
|
|
DeviceGetBAR1MemoryInfoFunc func(device nvml.Device) (nvml.BAR1Memory, nvml.Return)
|
|
|
|
// DeviceGetBoardIdFunc mocks the DeviceGetBoardId method.
|
|
DeviceGetBoardIdFunc func(device nvml.Device) (uint32, nvml.Return)
|
|
|
|
// DeviceGetBoardPartNumberFunc mocks the DeviceGetBoardPartNumber method.
|
|
DeviceGetBoardPartNumberFunc func(device nvml.Device) (string, nvml.Return)
|
|
|
|
// DeviceGetBrandFunc mocks the DeviceGetBrand method.
|
|
DeviceGetBrandFunc func(device nvml.Device) (nvml.BrandType, nvml.Return)
|
|
|
|
// DeviceGetBridgeChipInfoFunc mocks the DeviceGetBridgeChipInfo method.
|
|
DeviceGetBridgeChipInfoFunc func(device nvml.Device) (nvml.BridgeChipHierarchy, nvml.Return)
|
|
|
|
// DeviceGetBusTypeFunc mocks the DeviceGetBusType method.
|
|
DeviceGetBusTypeFunc func(device nvml.Device) (nvml.BusType, nvml.Return)
|
|
|
|
// DeviceGetClkMonStatusFunc mocks the DeviceGetClkMonStatus method.
|
|
DeviceGetClkMonStatusFunc func(device nvml.Device) (nvml.ClkMonStatus, nvml.Return)
|
|
|
|
// DeviceGetClockFunc mocks the DeviceGetClock method.
|
|
DeviceGetClockFunc func(device nvml.Device, clockType nvml.ClockType, clockId nvml.ClockId) (uint32, nvml.Return)
|
|
|
|
// DeviceGetClockInfoFunc mocks the DeviceGetClockInfo method.
|
|
DeviceGetClockInfoFunc func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return)
|
|
|
|
// DeviceGetComputeInstanceIdFunc mocks the DeviceGetComputeInstanceId method.
|
|
DeviceGetComputeInstanceIdFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetComputeModeFunc mocks the DeviceGetComputeMode method.
|
|
DeviceGetComputeModeFunc func(device nvml.Device) (nvml.ComputeMode, nvml.Return)
|
|
|
|
// DeviceGetComputeRunningProcessesFunc mocks the DeviceGetComputeRunningProcesses method.
|
|
DeviceGetComputeRunningProcessesFunc func(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return)
|
|
|
|
// DeviceGetCountFunc mocks the DeviceGetCount method.
|
|
DeviceGetCountFunc func() (int, nvml.Return)
|
|
|
|
// DeviceGetCpuAffinityFunc mocks the DeviceGetCpuAffinity method.
|
|
DeviceGetCpuAffinityFunc func(device nvml.Device, n int) ([]uint, nvml.Return)
|
|
|
|
// DeviceGetCpuAffinityWithinScopeFunc mocks the DeviceGetCpuAffinityWithinScope method.
|
|
DeviceGetCpuAffinityWithinScopeFunc func(device nvml.Device, n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return)
|
|
|
|
// DeviceGetCreatableVgpusFunc mocks the DeviceGetCreatableVgpus method.
|
|
DeviceGetCreatableVgpusFunc func(device nvml.Device) ([]nvml.VgpuTypeId, nvml.Return)
|
|
|
|
// DeviceGetCudaComputeCapabilityFunc mocks the DeviceGetCudaComputeCapability method.
|
|
DeviceGetCudaComputeCapabilityFunc func(device nvml.Device) (int, int, nvml.Return)
|
|
|
|
// DeviceGetCurrPcieLinkGenerationFunc mocks the DeviceGetCurrPcieLinkGeneration method.
|
|
DeviceGetCurrPcieLinkGenerationFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetCurrPcieLinkWidthFunc mocks the DeviceGetCurrPcieLinkWidth method.
|
|
DeviceGetCurrPcieLinkWidthFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetCurrentClocksThrottleReasonsFunc mocks the DeviceGetCurrentClocksThrottleReasons method.
|
|
DeviceGetCurrentClocksThrottleReasonsFunc func(device nvml.Device) (uint64, nvml.Return)
|
|
|
|
// DeviceGetDecoderUtilizationFunc mocks the DeviceGetDecoderUtilization method.
|
|
DeviceGetDecoderUtilizationFunc func(device nvml.Device) (uint32, uint32, nvml.Return)
|
|
|
|
// DeviceGetDefaultApplicationsClockFunc mocks the DeviceGetDefaultApplicationsClock method.
|
|
DeviceGetDefaultApplicationsClockFunc func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return)
|
|
|
|
// DeviceGetDefaultEccModeFunc mocks the DeviceGetDefaultEccMode method.
|
|
DeviceGetDefaultEccModeFunc func(device nvml.Device) (nvml.EnableState, nvml.Return)
|
|
|
|
// DeviceGetDetailedEccErrorsFunc mocks the DeviceGetDetailedEccErrors method.
|
|
DeviceGetDetailedEccErrorsFunc func(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (nvml.EccErrorCounts, nvml.Return)
|
|
|
|
// DeviceGetDeviceHandleFromMigDeviceHandleFunc mocks the DeviceGetDeviceHandleFromMigDeviceHandle method.
|
|
DeviceGetDeviceHandleFromMigDeviceHandleFunc func(device nvml.Device) (nvml.Device, nvml.Return)
|
|
|
|
// DeviceGetDisplayActiveFunc mocks the DeviceGetDisplayActive method.
|
|
DeviceGetDisplayActiveFunc func(device nvml.Device) (nvml.EnableState, nvml.Return)
|
|
|
|
// DeviceGetDisplayModeFunc mocks the DeviceGetDisplayMode method.
|
|
DeviceGetDisplayModeFunc func(device nvml.Device) (nvml.EnableState, nvml.Return)
|
|
|
|
// DeviceGetDriverModelFunc mocks the DeviceGetDriverModel method.
|
|
DeviceGetDriverModelFunc func(device nvml.Device) (nvml.DriverModel, nvml.DriverModel, nvml.Return)
|
|
|
|
// DeviceGetDynamicPstatesInfoFunc mocks the DeviceGetDynamicPstatesInfo method.
|
|
DeviceGetDynamicPstatesInfoFunc func(device nvml.Device) (nvml.GpuDynamicPstatesInfo, nvml.Return)
|
|
|
|
// DeviceGetEccModeFunc mocks the DeviceGetEccMode method.
|
|
DeviceGetEccModeFunc func(device nvml.Device) (nvml.EnableState, nvml.EnableState, nvml.Return)
|
|
|
|
// DeviceGetEncoderCapacityFunc mocks the DeviceGetEncoderCapacity method.
|
|
DeviceGetEncoderCapacityFunc func(device nvml.Device, encoderType nvml.EncoderType) (int, nvml.Return)
|
|
|
|
// DeviceGetEncoderSessionsFunc mocks the DeviceGetEncoderSessions method.
|
|
DeviceGetEncoderSessionsFunc func(device nvml.Device) ([]nvml.EncoderSessionInfo, nvml.Return)
|
|
|
|
// DeviceGetEncoderStatsFunc mocks the DeviceGetEncoderStats method.
|
|
DeviceGetEncoderStatsFunc func(device nvml.Device) (int, uint32, uint32, nvml.Return)
|
|
|
|
// DeviceGetEncoderUtilizationFunc mocks the DeviceGetEncoderUtilization method.
|
|
DeviceGetEncoderUtilizationFunc func(device nvml.Device) (uint32, uint32, nvml.Return)
|
|
|
|
// DeviceGetEnforcedPowerLimitFunc mocks the DeviceGetEnforcedPowerLimit method.
|
|
DeviceGetEnforcedPowerLimitFunc func(device nvml.Device) (uint32, nvml.Return)
|
|
|
|
// DeviceGetFBCSessionsFunc mocks the DeviceGetFBCSessions method.
|
|
DeviceGetFBCSessionsFunc func(device nvml.Device) ([]nvml.FBCSessionInfo, nvml.Return)
|
|
|
|
// DeviceGetFBCStatsFunc mocks the DeviceGetFBCStats method.
|
|
DeviceGetFBCStatsFunc func(device nvml.Device) (nvml.FBCStats, nvml.Return)
|
|
|
|
// DeviceGetFanControlPolicy_v2Func mocks the DeviceGetFanControlPolicy_v2 method.
|
|
DeviceGetFanControlPolicy_v2Func func(device nvml.Device, n int) (nvml.FanControlPolicy, nvml.Return)
|
|
|
|
// DeviceGetFanSpeedFunc mocks the DeviceGetFanSpeed method.
|
|
DeviceGetFanSpeedFunc func(device nvml.Device) (uint32, nvml.Return)
|
|
|
|
// DeviceGetFanSpeed_v2Func mocks the DeviceGetFanSpeed_v2 method.
|
|
DeviceGetFanSpeed_v2Func func(device nvml.Device, n int) (uint32, nvml.Return)
|
|
|
|
// DeviceGetFieldValuesFunc mocks the DeviceGetFieldValues method.
|
|
DeviceGetFieldValuesFunc func(device nvml.Device, fieldValues []nvml.FieldValue) nvml.Return
|
|
|
|
// DeviceGetGpcClkMinMaxVfOffsetFunc mocks the DeviceGetGpcClkMinMaxVfOffset method.
|
|
DeviceGetGpcClkMinMaxVfOffsetFunc func(device nvml.Device) (int, int, nvml.Return)
|
|
|
|
// DeviceGetGpcClkVfOffsetFunc mocks the DeviceGetGpcClkVfOffset method.
|
|
DeviceGetGpcClkVfOffsetFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetGpuFabricInfoFunc mocks the DeviceGetGpuFabricInfo method.
|
|
DeviceGetGpuFabricInfoFunc func(device nvml.Device) (nvml.GpuFabricInfo, nvml.Return)
|
|
|
|
// DeviceGetGpuInstanceByIdFunc mocks the DeviceGetGpuInstanceById method.
|
|
DeviceGetGpuInstanceByIdFunc func(device nvml.Device, n int) (nvml.GpuInstance, nvml.Return)
|
|
|
|
// DeviceGetGpuInstanceIdFunc mocks the DeviceGetGpuInstanceId method.
|
|
DeviceGetGpuInstanceIdFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetGpuInstancePossiblePlacementsFunc mocks the DeviceGetGpuInstancePossiblePlacements method.
|
|
DeviceGetGpuInstancePossiblePlacementsFunc func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstancePlacement, nvml.Return)
|
|
|
|
// DeviceGetGpuInstanceProfileInfoFunc mocks the DeviceGetGpuInstanceProfileInfo method.
|
|
DeviceGetGpuInstanceProfileInfoFunc func(device nvml.Device, n int) (nvml.GpuInstanceProfileInfo, nvml.Return)
|
|
|
|
// DeviceGetGpuInstanceProfileInfoVFunc mocks the DeviceGetGpuInstanceProfileInfoV method.
|
|
DeviceGetGpuInstanceProfileInfoVFunc func(device nvml.Device, n int) nvml.GpuInstanceProfileInfoV
|
|
|
|
// DeviceGetGpuInstanceRemainingCapacityFunc mocks the DeviceGetGpuInstanceRemainingCapacity method.
|
|
DeviceGetGpuInstanceRemainingCapacityFunc func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (int, nvml.Return)
|
|
|
|
// DeviceGetGpuInstancesFunc mocks the DeviceGetGpuInstances method.
|
|
DeviceGetGpuInstancesFunc func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstance, nvml.Return)
|
|
|
|
// DeviceGetGpuMaxPcieLinkGenerationFunc mocks the DeviceGetGpuMaxPcieLinkGeneration method.
|
|
DeviceGetGpuMaxPcieLinkGenerationFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetGpuOperationModeFunc mocks the DeviceGetGpuOperationMode method.
|
|
DeviceGetGpuOperationModeFunc func(device nvml.Device) (nvml.GpuOperationMode, nvml.GpuOperationMode, nvml.Return)
|
|
|
|
// DeviceGetGraphicsRunningProcessesFunc mocks the DeviceGetGraphicsRunningProcesses method.
|
|
DeviceGetGraphicsRunningProcessesFunc func(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return)
|
|
|
|
// DeviceGetGridLicensableFeaturesFunc mocks the DeviceGetGridLicensableFeatures method.
|
|
DeviceGetGridLicensableFeaturesFunc func(device nvml.Device) (nvml.GridLicensableFeatures, nvml.Return)
|
|
|
|
// DeviceGetGspFirmwareModeFunc mocks the DeviceGetGspFirmwareMode method.
|
|
DeviceGetGspFirmwareModeFunc func(device nvml.Device) (bool, bool, nvml.Return)
|
|
|
|
// DeviceGetGspFirmwareVersionFunc mocks the DeviceGetGspFirmwareVersion method.
|
|
DeviceGetGspFirmwareVersionFunc func(device nvml.Device) (string, nvml.Return)
|
|
|
|
// DeviceGetHandleByIndexFunc mocks the DeviceGetHandleByIndex method.
|
|
DeviceGetHandleByIndexFunc func(n int) (nvml.Device, nvml.Return)
|
|
|
|
// DeviceGetHandleByPciBusIdFunc mocks the DeviceGetHandleByPciBusId method.
|
|
DeviceGetHandleByPciBusIdFunc func(s string) (nvml.Device, nvml.Return)
|
|
|
|
// DeviceGetHandleBySerialFunc mocks the DeviceGetHandleBySerial method.
|
|
DeviceGetHandleBySerialFunc func(s string) (nvml.Device, nvml.Return)
|
|
|
|
// DeviceGetHandleByUUIDFunc mocks the DeviceGetHandleByUUID method.
|
|
DeviceGetHandleByUUIDFunc func(s string) (nvml.Device, nvml.Return)
|
|
|
|
// DeviceGetHostVgpuModeFunc mocks the DeviceGetHostVgpuMode method.
|
|
DeviceGetHostVgpuModeFunc func(device nvml.Device) (nvml.HostVgpuMode, nvml.Return)
|
|
|
|
// DeviceGetIndexFunc mocks the DeviceGetIndex method.
|
|
DeviceGetIndexFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetInforomConfigurationChecksumFunc mocks the DeviceGetInforomConfigurationChecksum method.
|
|
DeviceGetInforomConfigurationChecksumFunc func(device nvml.Device) (uint32, nvml.Return)
|
|
|
|
// DeviceGetInforomImageVersionFunc mocks the DeviceGetInforomImageVersion method.
|
|
DeviceGetInforomImageVersionFunc func(device nvml.Device) (string, nvml.Return)
|
|
|
|
// DeviceGetInforomVersionFunc mocks the DeviceGetInforomVersion method.
|
|
DeviceGetInforomVersionFunc func(device nvml.Device, inforomObject nvml.InforomObject) (string, nvml.Return)
|
|
|
|
// DeviceGetIrqNumFunc mocks the DeviceGetIrqNum method.
|
|
DeviceGetIrqNumFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetMPSComputeRunningProcessesFunc mocks the DeviceGetMPSComputeRunningProcesses method.
|
|
DeviceGetMPSComputeRunningProcessesFunc func(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return)
|
|
|
|
// DeviceGetMaxClockInfoFunc mocks the DeviceGetMaxClockInfo method.
|
|
DeviceGetMaxClockInfoFunc func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return)
|
|
|
|
// DeviceGetMaxCustomerBoostClockFunc mocks the DeviceGetMaxCustomerBoostClock method.
|
|
DeviceGetMaxCustomerBoostClockFunc func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return)
|
|
|
|
// DeviceGetMaxMigDeviceCountFunc mocks the DeviceGetMaxMigDeviceCount method.
|
|
DeviceGetMaxMigDeviceCountFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetMaxPcieLinkGenerationFunc mocks the DeviceGetMaxPcieLinkGeneration method.
|
|
DeviceGetMaxPcieLinkGenerationFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetMaxPcieLinkWidthFunc mocks the DeviceGetMaxPcieLinkWidth method.
|
|
DeviceGetMaxPcieLinkWidthFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetMemClkMinMaxVfOffsetFunc mocks the DeviceGetMemClkMinMaxVfOffset method.
|
|
DeviceGetMemClkMinMaxVfOffsetFunc func(device nvml.Device) (int, int, nvml.Return)
|
|
|
|
// DeviceGetMemClkVfOffsetFunc mocks the DeviceGetMemClkVfOffset method.
|
|
DeviceGetMemClkVfOffsetFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetMemoryAffinityFunc mocks the DeviceGetMemoryAffinity method.
|
|
DeviceGetMemoryAffinityFunc func(device nvml.Device, n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return)
|
|
|
|
// DeviceGetMemoryBusWidthFunc mocks the DeviceGetMemoryBusWidth method.
|
|
DeviceGetMemoryBusWidthFunc func(device nvml.Device) (uint32, nvml.Return)
|
|
|
|
// DeviceGetMemoryErrorCounterFunc mocks the DeviceGetMemoryErrorCounter method.
|
|
DeviceGetMemoryErrorCounterFunc func(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType, memoryLocation nvml.MemoryLocation) (uint64, nvml.Return)
|
|
|
|
// DeviceGetMemoryInfoFunc mocks the DeviceGetMemoryInfo method.
|
|
DeviceGetMemoryInfoFunc func(device nvml.Device) (nvml.Memory, nvml.Return)
|
|
|
|
// DeviceGetMemoryInfo_v2Func mocks the DeviceGetMemoryInfo_v2 method.
|
|
DeviceGetMemoryInfo_v2Func func(device nvml.Device) (nvml.Memory_v2, nvml.Return)
|
|
|
|
// DeviceGetMigDeviceHandleByIndexFunc mocks the DeviceGetMigDeviceHandleByIndex method.
|
|
DeviceGetMigDeviceHandleByIndexFunc func(device nvml.Device, n int) (nvml.Device, nvml.Return)
|
|
|
|
// DeviceGetMigModeFunc mocks the DeviceGetMigMode method.
|
|
DeviceGetMigModeFunc func(device nvml.Device) (int, int, nvml.Return)
|
|
|
|
// DeviceGetMinMaxClockOfPStateFunc mocks the DeviceGetMinMaxClockOfPState method.
|
|
DeviceGetMinMaxClockOfPStateFunc func(device nvml.Device, clockType nvml.ClockType, pstates nvml.Pstates) (uint32, uint32, nvml.Return)
|
|
|
|
// DeviceGetMinMaxFanSpeedFunc mocks the DeviceGetMinMaxFanSpeed method.
|
|
DeviceGetMinMaxFanSpeedFunc func(device nvml.Device) (int, int, nvml.Return)
|
|
|
|
// DeviceGetMinorNumberFunc mocks the DeviceGetMinorNumber method.
|
|
DeviceGetMinorNumberFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetMultiGpuBoardFunc mocks the DeviceGetMultiGpuBoard method.
|
|
DeviceGetMultiGpuBoardFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetNameFunc mocks the DeviceGetName method.
|
|
DeviceGetNameFunc func(device nvml.Device) (string, nvml.Return)
|
|
|
|
// DeviceGetNumFansFunc mocks the DeviceGetNumFans method.
|
|
DeviceGetNumFansFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetNumGpuCoresFunc mocks the DeviceGetNumGpuCores method.
|
|
DeviceGetNumGpuCoresFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetNvLinkCapabilityFunc mocks the DeviceGetNvLinkCapability method.
|
|
DeviceGetNvLinkCapabilityFunc func(device nvml.Device, n int, nvLinkCapability nvml.NvLinkCapability) (uint32, nvml.Return)
|
|
|
|
// DeviceGetNvLinkErrorCounterFunc mocks the DeviceGetNvLinkErrorCounter method.
|
|
DeviceGetNvLinkErrorCounterFunc func(device nvml.Device, n int, nvLinkErrorCounter nvml.NvLinkErrorCounter) (uint64, nvml.Return)
|
|
|
|
// DeviceGetNvLinkRemoteDeviceTypeFunc mocks the DeviceGetNvLinkRemoteDeviceType method.
|
|
DeviceGetNvLinkRemoteDeviceTypeFunc func(device nvml.Device, n int) (nvml.IntNvLinkDeviceType, nvml.Return)
|
|
|
|
// DeviceGetNvLinkRemotePciInfoFunc mocks the DeviceGetNvLinkRemotePciInfo method.
|
|
DeviceGetNvLinkRemotePciInfoFunc func(device nvml.Device, n int) (nvml.PciInfo, nvml.Return)
|
|
|
|
// DeviceGetNvLinkStateFunc mocks the DeviceGetNvLinkState method.
|
|
DeviceGetNvLinkStateFunc func(device nvml.Device, n int) (nvml.EnableState, nvml.Return)
|
|
|
|
// DeviceGetNvLinkUtilizationControlFunc mocks the DeviceGetNvLinkUtilizationControl method.
|
|
DeviceGetNvLinkUtilizationControlFunc func(device nvml.Device, n1 int, n2 int) (nvml.NvLinkUtilizationControl, nvml.Return)
|
|
|
|
// DeviceGetNvLinkUtilizationCounterFunc mocks the DeviceGetNvLinkUtilizationCounter method.
|
|
DeviceGetNvLinkUtilizationCounterFunc func(device nvml.Device, n1 int, n2 int) (uint64, uint64, nvml.Return)
|
|
|
|
// DeviceGetNvLinkVersionFunc mocks the DeviceGetNvLinkVersion method.
|
|
DeviceGetNvLinkVersionFunc func(device nvml.Device, n int) (uint32, nvml.Return)
|
|
|
|
// DeviceGetP2PStatusFunc mocks the DeviceGetP2PStatus method.
|
|
DeviceGetP2PStatusFunc func(device1 nvml.Device, device2 nvml.Device, gpuP2PCapsIndex nvml.GpuP2PCapsIndex) (nvml.GpuP2PStatus, nvml.Return)
|
|
|
|
// DeviceGetPciInfoFunc mocks the DeviceGetPciInfo method.
|
|
DeviceGetPciInfoFunc func(device nvml.Device) (nvml.PciInfo, nvml.Return)
|
|
|
|
// DeviceGetPcieLinkMaxSpeedFunc mocks the DeviceGetPcieLinkMaxSpeed method.
|
|
DeviceGetPcieLinkMaxSpeedFunc func(device nvml.Device) (uint32, nvml.Return)
|
|
|
|
// DeviceGetPcieReplayCounterFunc mocks the DeviceGetPcieReplayCounter method.
|
|
DeviceGetPcieReplayCounterFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetPcieSpeedFunc mocks the DeviceGetPcieSpeed method.
|
|
DeviceGetPcieSpeedFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceGetPcieThroughputFunc mocks the DeviceGetPcieThroughput method.
|
|
DeviceGetPcieThroughputFunc func(device nvml.Device, pcieUtilCounter nvml.PcieUtilCounter) (uint32, nvml.Return)
|
|
|
|
// DeviceGetPerformanceStateFunc mocks the DeviceGetPerformanceState method.
|
|
DeviceGetPerformanceStateFunc func(device nvml.Device) (nvml.Pstates, nvml.Return)
|
|
|
|
// DeviceGetPersistenceModeFunc mocks the DeviceGetPersistenceMode method.
|
|
DeviceGetPersistenceModeFunc func(device nvml.Device) (nvml.EnableState, nvml.Return)
|
|
|
|
// DeviceGetPgpuMetadataStringFunc mocks the DeviceGetPgpuMetadataString method.
|
|
DeviceGetPgpuMetadataStringFunc func(device nvml.Device) (string, nvml.Return)
|
|
|
|
// DeviceGetPowerManagementDefaultLimitFunc mocks the DeviceGetPowerManagementDefaultLimit method.
|
|
DeviceGetPowerManagementDefaultLimitFunc func(device nvml.Device) (uint32, nvml.Return)
|
|
|
|
// DeviceGetPowerManagementLimitFunc mocks the DeviceGetPowerManagementLimit method.
|
|
DeviceGetPowerManagementLimitFunc func(device nvml.Device) (uint32, nvml.Return)
|
|
|
|
// DeviceGetPowerManagementLimitConstraintsFunc mocks the DeviceGetPowerManagementLimitConstraints method.
|
|
DeviceGetPowerManagementLimitConstraintsFunc func(device nvml.Device) (uint32, uint32, nvml.Return)
|
|
|
|
// DeviceGetPowerManagementModeFunc mocks the DeviceGetPowerManagementMode method.
|
|
DeviceGetPowerManagementModeFunc func(device nvml.Device) (nvml.EnableState, nvml.Return)
|
|
|
|
// DeviceGetPowerSourceFunc mocks the DeviceGetPowerSource method.
|
|
DeviceGetPowerSourceFunc func(device nvml.Device) (nvml.PowerSource, nvml.Return)
|
|
|
|
// DeviceGetPowerStateFunc mocks the DeviceGetPowerState method.
|
|
DeviceGetPowerStateFunc func(device nvml.Device) (nvml.Pstates, nvml.Return)
|
|
|
|
// DeviceGetPowerUsageFunc mocks the DeviceGetPowerUsage method.
|
|
DeviceGetPowerUsageFunc func(device nvml.Device) (uint32, nvml.Return)
|
|
|
|
// DeviceGetProcessUtilizationFunc mocks the DeviceGetProcessUtilization method.
|
|
DeviceGetProcessUtilizationFunc func(device nvml.Device, v uint64) ([]nvml.ProcessUtilizationSample, nvml.Return)
|
|
|
|
// DeviceGetRemappedRowsFunc mocks the DeviceGetRemappedRows method.
|
|
DeviceGetRemappedRowsFunc func(device nvml.Device) (int, int, bool, bool, nvml.Return)
|
|
|
|
// DeviceGetRetiredPagesFunc mocks the DeviceGetRetiredPages method.
|
|
DeviceGetRetiredPagesFunc func(device nvml.Device, pageRetirementCause nvml.PageRetirementCause) ([]uint64, nvml.Return)
|
|
|
|
// DeviceGetRetiredPagesPendingStatusFunc mocks the DeviceGetRetiredPagesPendingStatus method.
|
|
DeviceGetRetiredPagesPendingStatusFunc func(device nvml.Device) (nvml.EnableState, nvml.Return)
|
|
|
|
// DeviceGetRetiredPages_v2Func mocks the DeviceGetRetiredPages_v2 method.
|
|
DeviceGetRetiredPages_v2Func func(device nvml.Device, pageRetirementCause nvml.PageRetirementCause) ([]uint64, []uint64, nvml.Return)
|
|
|
|
// DeviceGetRowRemapperHistogramFunc mocks the DeviceGetRowRemapperHistogram method.
|
|
DeviceGetRowRemapperHistogramFunc func(device nvml.Device) (nvml.RowRemapperHistogramValues, nvml.Return)
|
|
|
|
// DeviceGetSamplesFunc mocks the DeviceGetSamples method.
|
|
DeviceGetSamplesFunc func(device nvml.Device, samplingType nvml.SamplingType, v uint64) (nvml.ValueType, []nvml.Sample, nvml.Return)
|
|
|
|
// DeviceGetSerialFunc mocks the DeviceGetSerial method.
|
|
DeviceGetSerialFunc func(device nvml.Device) (string, nvml.Return)
|
|
|
|
// DeviceGetSupportedClocksThrottleReasonsFunc mocks the DeviceGetSupportedClocksThrottleReasons method.
|
|
DeviceGetSupportedClocksThrottleReasonsFunc func(device nvml.Device) (uint64, nvml.Return)
|
|
|
|
// DeviceGetSupportedEventTypesFunc mocks the DeviceGetSupportedEventTypes method.
|
|
DeviceGetSupportedEventTypesFunc func(device nvml.Device) (uint64, nvml.Return)
|
|
|
|
// DeviceGetSupportedGraphicsClocksFunc mocks the DeviceGetSupportedGraphicsClocks method.
|
|
DeviceGetSupportedGraphicsClocksFunc func(device nvml.Device, n int) (int, uint32, nvml.Return)
|
|
|
|
// DeviceGetSupportedMemoryClocksFunc mocks the DeviceGetSupportedMemoryClocks method.
|
|
DeviceGetSupportedMemoryClocksFunc func(device nvml.Device) (int, uint32, nvml.Return)
|
|
|
|
// DeviceGetSupportedPerformanceStatesFunc mocks the DeviceGetSupportedPerformanceStates method.
|
|
DeviceGetSupportedPerformanceStatesFunc func(device nvml.Device) ([]nvml.Pstates, nvml.Return)
|
|
|
|
// DeviceGetSupportedVgpusFunc mocks the DeviceGetSupportedVgpus method.
|
|
DeviceGetSupportedVgpusFunc func(device nvml.Device) ([]nvml.VgpuTypeId, nvml.Return)
|
|
|
|
// DeviceGetTargetFanSpeedFunc mocks the DeviceGetTargetFanSpeed method.
|
|
DeviceGetTargetFanSpeedFunc func(device nvml.Device, n int) (int, nvml.Return)
|
|
|
|
// DeviceGetTemperatureFunc mocks the DeviceGetTemperature method.
|
|
DeviceGetTemperatureFunc func(device nvml.Device, temperatureSensors nvml.TemperatureSensors) (uint32, nvml.Return)
|
|
|
|
// DeviceGetTemperatureThresholdFunc mocks the DeviceGetTemperatureThreshold method.
|
|
DeviceGetTemperatureThresholdFunc func(device nvml.Device, temperatureThresholds nvml.TemperatureThresholds) (uint32, nvml.Return)
|
|
|
|
// DeviceGetThermalSettingsFunc mocks the DeviceGetThermalSettings method.
|
|
DeviceGetThermalSettingsFunc func(device nvml.Device, v uint32) (nvml.GpuThermalSettings, nvml.Return)
|
|
|
|
// DeviceGetTopologyCommonAncestorFunc mocks the DeviceGetTopologyCommonAncestor method.
|
|
DeviceGetTopologyCommonAncestorFunc func(device1 nvml.Device, device2 nvml.Device) (nvml.GpuTopologyLevel, nvml.Return)
|
|
|
|
// DeviceGetTopologyNearestGpusFunc mocks the DeviceGetTopologyNearestGpus method.
|
|
DeviceGetTopologyNearestGpusFunc func(device nvml.Device, gpuTopologyLevel nvml.GpuTopologyLevel) ([]nvml.Device, nvml.Return)
|
|
|
|
// DeviceGetTotalEccErrorsFunc mocks the DeviceGetTotalEccErrors method.
|
|
DeviceGetTotalEccErrorsFunc func(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (uint64, nvml.Return)
|
|
|
|
// DeviceGetTotalEnergyConsumptionFunc mocks the DeviceGetTotalEnergyConsumption method.
|
|
DeviceGetTotalEnergyConsumptionFunc func(device nvml.Device) (uint64, nvml.Return)
|
|
|
|
// DeviceGetUUIDFunc mocks the DeviceGetUUID method.
|
|
DeviceGetUUIDFunc func(device nvml.Device) (string, nvml.Return)
|
|
|
|
// DeviceGetUtilizationRatesFunc mocks the DeviceGetUtilizationRates method.
|
|
DeviceGetUtilizationRatesFunc func(device nvml.Device) (nvml.Utilization, nvml.Return)
|
|
|
|
// DeviceGetVbiosVersionFunc mocks the DeviceGetVbiosVersion method.
|
|
DeviceGetVbiosVersionFunc func(device nvml.Device) (string, nvml.Return)
|
|
|
|
// DeviceGetVgpuCapabilitiesFunc mocks the DeviceGetVgpuCapabilities method.
|
|
DeviceGetVgpuCapabilitiesFunc func(device nvml.Device, deviceVgpuCapability nvml.DeviceVgpuCapability) (bool, nvml.Return)
|
|
|
|
// DeviceGetVgpuMetadataFunc mocks the DeviceGetVgpuMetadata method.
|
|
DeviceGetVgpuMetadataFunc func(device nvml.Device) (nvml.VgpuPgpuMetadata, nvml.Return)
|
|
|
|
// DeviceGetVgpuProcessUtilizationFunc mocks the DeviceGetVgpuProcessUtilization method.
|
|
DeviceGetVgpuProcessUtilizationFunc func(device nvml.Device, v uint64) ([]nvml.VgpuProcessUtilizationSample, nvml.Return)
|
|
|
|
// DeviceGetVgpuSchedulerCapabilitiesFunc mocks the DeviceGetVgpuSchedulerCapabilities method.
|
|
DeviceGetVgpuSchedulerCapabilitiesFunc func(device nvml.Device) (nvml.VgpuSchedulerCapabilities, nvml.Return)
|
|
|
|
// DeviceGetVgpuSchedulerLogFunc mocks the DeviceGetVgpuSchedulerLog method.
|
|
DeviceGetVgpuSchedulerLogFunc func(device nvml.Device) (nvml.VgpuSchedulerLog, nvml.Return)
|
|
|
|
// DeviceGetVgpuSchedulerStateFunc mocks the DeviceGetVgpuSchedulerState method.
|
|
DeviceGetVgpuSchedulerStateFunc func(device nvml.Device) (nvml.VgpuSchedulerGetState, nvml.Return)
|
|
|
|
// DeviceGetVgpuUtilizationFunc mocks the DeviceGetVgpuUtilization method.
|
|
DeviceGetVgpuUtilizationFunc func(device nvml.Device, v uint64) (nvml.ValueType, []nvml.VgpuInstanceUtilizationSample, nvml.Return)
|
|
|
|
// DeviceGetViolationStatusFunc mocks the DeviceGetViolationStatus method.
|
|
DeviceGetViolationStatusFunc func(device nvml.Device, perfPolicyType nvml.PerfPolicyType) (nvml.ViolationTime, nvml.Return)
|
|
|
|
// DeviceGetVirtualizationModeFunc mocks the DeviceGetVirtualizationMode method.
|
|
DeviceGetVirtualizationModeFunc func(device nvml.Device) (nvml.GpuVirtualizationMode, nvml.Return)
|
|
|
|
// DeviceIsMigDeviceHandleFunc mocks the DeviceIsMigDeviceHandle method.
|
|
DeviceIsMigDeviceHandleFunc func(device nvml.Device) (bool, nvml.Return)
|
|
|
|
// DeviceModifyDrainStateFunc mocks the DeviceModifyDrainState method.
|
|
DeviceModifyDrainStateFunc func(pciInfo *nvml.PciInfo, enableState nvml.EnableState) nvml.Return
|
|
|
|
// DeviceOnSameBoardFunc mocks the DeviceOnSameBoard method.
|
|
DeviceOnSameBoardFunc func(device1 nvml.Device, device2 nvml.Device) (int, nvml.Return)
|
|
|
|
// DeviceQueryDrainStateFunc mocks the DeviceQueryDrainState method.
|
|
DeviceQueryDrainStateFunc func(pciInfo *nvml.PciInfo) (nvml.EnableState, nvml.Return)
|
|
|
|
// DeviceRegisterEventsFunc mocks the DeviceRegisterEvents method.
|
|
DeviceRegisterEventsFunc func(device nvml.Device, v uint64, eventSet nvml.EventSet) nvml.Return
|
|
|
|
// DeviceRemoveGpuFunc mocks the DeviceRemoveGpu method.
|
|
DeviceRemoveGpuFunc func(pciInfo *nvml.PciInfo) nvml.Return
|
|
|
|
// DeviceRemoveGpu_v2Func mocks the DeviceRemoveGpu_v2 method.
|
|
DeviceRemoveGpu_v2Func func(pciInfo *nvml.PciInfo, detachGpuState nvml.DetachGpuState, pcieLinkState nvml.PcieLinkState) nvml.Return
|
|
|
|
// DeviceResetApplicationsClocksFunc mocks the DeviceResetApplicationsClocks method.
|
|
DeviceResetApplicationsClocksFunc func(device nvml.Device) nvml.Return
|
|
|
|
// DeviceResetGpuLockedClocksFunc mocks the DeviceResetGpuLockedClocks method.
|
|
DeviceResetGpuLockedClocksFunc func(device nvml.Device) nvml.Return
|
|
|
|
// DeviceResetMemoryLockedClocksFunc mocks the DeviceResetMemoryLockedClocks method.
|
|
DeviceResetMemoryLockedClocksFunc func(device nvml.Device) nvml.Return
|
|
|
|
// DeviceResetNvLinkErrorCountersFunc mocks the DeviceResetNvLinkErrorCounters method.
|
|
DeviceResetNvLinkErrorCountersFunc func(device nvml.Device, n int) nvml.Return
|
|
|
|
// DeviceResetNvLinkUtilizationCounterFunc mocks the DeviceResetNvLinkUtilizationCounter method.
|
|
DeviceResetNvLinkUtilizationCounterFunc func(device nvml.Device, n1 int, n2 int) nvml.Return
|
|
|
|
// DeviceSetAPIRestrictionFunc mocks the DeviceSetAPIRestriction method.
|
|
DeviceSetAPIRestrictionFunc func(device nvml.Device, restrictedAPI nvml.RestrictedAPI, enableState nvml.EnableState) nvml.Return
|
|
|
|
// DeviceSetAccountingModeFunc mocks the DeviceSetAccountingMode method.
|
|
DeviceSetAccountingModeFunc func(device nvml.Device, enableState nvml.EnableState) nvml.Return
|
|
|
|
// DeviceSetApplicationsClocksFunc mocks the DeviceSetApplicationsClocks method.
|
|
DeviceSetApplicationsClocksFunc func(device nvml.Device, v1 uint32, v2 uint32) nvml.Return
|
|
|
|
// DeviceSetAutoBoostedClocksEnabledFunc mocks the DeviceSetAutoBoostedClocksEnabled method.
|
|
DeviceSetAutoBoostedClocksEnabledFunc func(device nvml.Device, enableState nvml.EnableState) nvml.Return
|
|
|
|
// DeviceSetComputeModeFunc mocks the DeviceSetComputeMode method.
|
|
DeviceSetComputeModeFunc func(device nvml.Device, computeMode nvml.ComputeMode) nvml.Return
|
|
|
|
// DeviceSetCpuAffinityFunc mocks the DeviceSetCpuAffinity method.
|
|
DeviceSetCpuAffinityFunc func(device nvml.Device) nvml.Return
|
|
|
|
// DeviceSetDefaultAutoBoostedClocksEnabledFunc mocks the DeviceSetDefaultAutoBoostedClocksEnabled method.
|
|
DeviceSetDefaultAutoBoostedClocksEnabledFunc func(device nvml.Device, enableState nvml.EnableState, v uint32) nvml.Return
|
|
|
|
// DeviceSetDefaultFanSpeed_v2Func mocks the DeviceSetDefaultFanSpeed_v2 method.
|
|
DeviceSetDefaultFanSpeed_v2Func func(device nvml.Device, n int) nvml.Return
|
|
|
|
// DeviceSetDriverModelFunc mocks the DeviceSetDriverModel method.
|
|
DeviceSetDriverModelFunc func(device nvml.Device, driverModel nvml.DriverModel, v uint32) nvml.Return
|
|
|
|
// DeviceSetEccModeFunc mocks the DeviceSetEccMode method.
|
|
DeviceSetEccModeFunc func(device nvml.Device, enableState nvml.EnableState) nvml.Return
|
|
|
|
// DeviceSetFanControlPolicyFunc mocks the DeviceSetFanControlPolicy method.
|
|
DeviceSetFanControlPolicyFunc func(device nvml.Device, n int, fanControlPolicy nvml.FanControlPolicy) nvml.Return
|
|
|
|
// DeviceSetFanSpeed_v2Func mocks the DeviceSetFanSpeed_v2 method.
|
|
DeviceSetFanSpeed_v2Func func(device nvml.Device, n1 int, n2 int) nvml.Return
|
|
|
|
// DeviceSetGpcClkVfOffsetFunc mocks the DeviceSetGpcClkVfOffset method.
|
|
DeviceSetGpcClkVfOffsetFunc func(device nvml.Device, n int) nvml.Return
|
|
|
|
// DeviceSetGpuLockedClocksFunc mocks the DeviceSetGpuLockedClocks method.
|
|
DeviceSetGpuLockedClocksFunc func(device nvml.Device, v1 uint32, v2 uint32) nvml.Return
|
|
|
|
// DeviceSetGpuOperationModeFunc mocks the DeviceSetGpuOperationMode method.
|
|
DeviceSetGpuOperationModeFunc func(device nvml.Device, gpuOperationMode nvml.GpuOperationMode) nvml.Return
|
|
|
|
// DeviceSetMemClkVfOffsetFunc mocks the DeviceSetMemClkVfOffset method.
|
|
DeviceSetMemClkVfOffsetFunc func(device nvml.Device, n int) nvml.Return
|
|
|
|
// DeviceSetMemoryLockedClocksFunc mocks the DeviceSetMemoryLockedClocks method.
|
|
DeviceSetMemoryLockedClocksFunc func(device nvml.Device, v1 uint32, v2 uint32) nvml.Return
|
|
|
|
// DeviceSetMigModeFunc mocks the DeviceSetMigMode method.
|
|
DeviceSetMigModeFunc func(device nvml.Device, n int) (nvml.Return, nvml.Return)
|
|
|
|
// DeviceSetNvLinkDeviceLowPowerThresholdFunc mocks the DeviceSetNvLinkDeviceLowPowerThreshold method.
|
|
DeviceSetNvLinkDeviceLowPowerThresholdFunc func(device nvml.Device, nvLinkPowerThres *nvml.NvLinkPowerThres) nvml.Return
|
|
|
|
// DeviceSetNvLinkUtilizationControlFunc mocks the DeviceSetNvLinkUtilizationControl method.
|
|
DeviceSetNvLinkUtilizationControlFunc func(device nvml.Device, n1 int, n2 int, nvLinkUtilizationControl *nvml.NvLinkUtilizationControl, b bool) nvml.Return
|
|
|
|
// DeviceSetPersistenceModeFunc mocks the DeviceSetPersistenceMode method.
|
|
DeviceSetPersistenceModeFunc func(device nvml.Device, enableState nvml.EnableState) nvml.Return
|
|
|
|
// DeviceSetPowerManagementLimitFunc mocks the DeviceSetPowerManagementLimit method.
|
|
DeviceSetPowerManagementLimitFunc func(device nvml.Device, v uint32) nvml.Return
|
|
|
|
// DeviceSetTemperatureThresholdFunc mocks the DeviceSetTemperatureThreshold method.
|
|
DeviceSetTemperatureThresholdFunc func(device nvml.Device, temperatureThresholds nvml.TemperatureThresholds, n int) nvml.Return
|
|
|
|
// DeviceSetVgpuSchedulerStateFunc mocks the DeviceSetVgpuSchedulerState method.
|
|
DeviceSetVgpuSchedulerStateFunc func(device nvml.Device, vgpuSchedulerSetState *nvml.VgpuSchedulerSetState) nvml.Return
|
|
|
|
// DeviceSetVirtualizationModeFunc mocks the DeviceSetVirtualizationMode method.
|
|
DeviceSetVirtualizationModeFunc func(device nvml.Device, gpuVirtualizationMode nvml.GpuVirtualizationMode) nvml.Return
|
|
|
|
// DeviceValidateInforomFunc mocks the DeviceValidateInforom method.
|
|
DeviceValidateInforomFunc func(device nvml.Device) nvml.Return
|
|
|
|
// ErrorStringFunc mocks the ErrorString method.
|
|
ErrorStringFunc func(returnMoqParam nvml.Return) string
|
|
|
|
// EventSetCreateFunc mocks the EventSetCreate method.
|
|
EventSetCreateFunc func() (nvml.EventSet, nvml.Return)
|
|
|
|
// EventSetFreeFunc mocks the EventSetFree method.
|
|
EventSetFreeFunc func(eventSet nvml.EventSet) nvml.Return
|
|
|
|
// EventSetWaitFunc mocks the EventSetWait method.
|
|
EventSetWaitFunc func(eventSet nvml.EventSet, v uint32) (nvml.EventData, nvml.Return)
|
|
|
|
// ExtensionsFunc mocks the Extensions method.
|
|
ExtensionsFunc func() nvml.ExtendedInterface
|
|
|
|
// GetExcludedDeviceCountFunc mocks the GetExcludedDeviceCount method.
|
|
GetExcludedDeviceCountFunc func() (int, nvml.Return)
|
|
|
|
// GetExcludedDeviceInfoByIndexFunc mocks the GetExcludedDeviceInfoByIndex method.
|
|
GetExcludedDeviceInfoByIndexFunc func(n int) (nvml.ExcludedDeviceInfo, nvml.Return)
|
|
|
|
// GetVgpuCompatibilityFunc mocks the GetVgpuCompatibility method.
|
|
GetVgpuCompatibilityFunc func(vgpuMetadata *nvml.VgpuMetadata, vgpuPgpuMetadata *nvml.VgpuPgpuMetadata) (nvml.VgpuPgpuCompatibility, nvml.Return)
|
|
|
|
// GetVgpuDriverCapabilitiesFunc mocks the GetVgpuDriverCapabilities method.
|
|
GetVgpuDriverCapabilitiesFunc func(vgpuDriverCapability nvml.VgpuDriverCapability) (bool, nvml.Return)
|
|
|
|
// GetVgpuVersionFunc mocks the GetVgpuVersion method.
|
|
GetVgpuVersionFunc func() (nvml.VgpuVersion, nvml.VgpuVersion, nvml.Return)
|
|
|
|
// GpmMetricsGetFunc mocks the GpmMetricsGet method.
|
|
GpmMetricsGetFunc func(gpmMetricsGetType *nvml.GpmMetricsGetType) nvml.Return
|
|
|
|
// GpmMetricsGetVFunc mocks the GpmMetricsGetV method.
|
|
GpmMetricsGetVFunc func(gpmMetricsGetType *nvml.GpmMetricsGetType) nvml.GpmMetricsGetVType
|
|
|
|
// GpmMigSampleGetFunc mocks the GpmMigSampleGet method.
|
|
GpmMigSampleGetFunc func(device nvml.Device, n int, gpmSample nvml.GpmSample) nvml.Return
|
|
|
|
// GpmQueryDeviceSupportFunc mocks the GpmQueryDeviceSupport method.
|
|
GpmQueryDeviceSupportFunc func(device nvml.Device) (nvml.GpmSupport, nvml.Return)
|
|
|
|
// GpmQueryDeviceSupportVFunc mocks the GpmQueryDeviceSupportV method.
|
|
GpmQueryDeviceSupportVFunc func(device nvml.Device) nvml.GpmSupportV
|
|
|
|
// GpmSampleAllocFunc mocks the GpmSampleAlloc method.
|
|
GpmSampleAllocFunc func() (nvml.GpmSample, nvml.Return)
|
|
|
|
// GpmSampleFreeFunc mocks the GpmSampleFree method.
|
|
GpmSampleFreeFunc func(gpmSample nvml.GpmSample) nvml.Return
|
|
|
|
// GpmSampleGetFunc mocks the GpmSampleGet method.
|
|
GpmSampleGetFunc func(device nvml.Device, gpmSample nvml.GpmSample) nvml.Return
|
|
|
|
// GpuInstanceCreateComputeInstanceFunc mocks the GpuInstanceCreateComputeInstance method.
|
|
GpuInstanceCreateComputeInstanceFunc func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) (nvml.ComputeInstance, nvml.Return)
|
|
|
|
// GpuInstanceCreateComputeInstanceWithPlacementFunc mocks the GpuInstanceCreateComputeInstanceWithPlacement method.
|
|
GpuInstanceCreateComputeInstanceWithPlacementFunc func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo, computeInstancePlacement *nvml.ComputeInstancePlacement) (nvml.ComputeInstance, nvml.Return)
|
|
|
|
// GpuInstanceDestroyFunc mocks the GpuInstanceDestroy method.
|
|
GpuInstanceDestroyFunc func(gpuInstance nvml.GpuInstance) nvml.Return
|
|
|
|
// GpuInstanceGetComputeInstanceByIdFunc mocks the GpuInstanceGetComputeInstanceById method.
|
|
GpuInstanceGetComputeInstanceByIdFunc func(gpuInstance nvml.GpuInstance, n int) (nvml.ComputeInstance, nvml.Return)
|
|
|
|
// GpuInstanceGetComputeInstancePossiblePlacementsFunc mocks the GpuInstanceGetComputeInstancePossiblePlacements method.
|
|
GpuInstanceGetComputeInstancePossiblePlacementsFunc func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) ([]nvml.ComputeInstancePlacement, nvml.Return)
|
|
|
|
// GpuInstanceGetComputeInstanceProfileInfoFunc mocks the GpuInstanceGetComputeInstanceProfileInfo method.
|
|
GpuInstanceGetComputeInstanceProfileInfoFunc func(gpuInstance nvml.GpuInstance, n1 int, n2 int) (nvml.ComputeInstanceProfileInfo, nvml.Return)
|
|
|
|
// GpuInstanceGetComputeInstanceProfileInfoVFunc mocks the GpuInstanceGetComputeInstanceProfileInfoV method.
|
|
GpuInstanceGetComputeInstanceProfileInfoVFunc func(gpuInstance nvml.GpuInstance, n1 int, n2 int) nvml.ComputeInstanceProfileInfoV
|
|
|
|
// GpuInstanceGetComputeInstanceRemainingCapacityFunc mocks the GpuInstanceGetComputeInstanceRemainingCapacity method.
|
|
GpuInstanceGetComputeInstanceRemainingCapacityFunc func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) (int, nvml.Return)
|
|
|
|
// GpuInstanceGetComputeInstancesFunc mocks the GpuInstanceGetComputeInstances method.
|
|
GpuInstanceGetComputeInstancesFunc func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) ([]nvml.ComputeInstance, nvml.Return)
|
|
|
|
// GpuInstanceGetInfoFunc mocks the GpuInstanceGetInfo method.
|
|
GpuInstanceGetInfoFunc func(gpuInstance nvml.GpuInstance) (nvml.GpuInstanceInfo, nvml.Return)
|
|
|
|
// InitFunc mocks the Init method.
|
|
InitFunc func() nvml.Return
|
|
|
|
// InitWithFlagsFunc mocks the InitWithFlags method.
|
|
InitWithFlagsFunc func(v uint32) nvml.Return
|
|
|
|
// SetVgpuVersionFunc mocks the SetVgpuVersion method.
|
|
SetVgpuVersionFunc func(vgpuVersion *nvml.VgpuVersion) nvml.Return
|
|
|
|
// ShutdownFunc mocks the Shutdown method.
|
|
ShutdownFunc func() nvml.Return
|
|
|
|
// SystemGetCudaDriverVersionFunc mocks the SystemGetCudaDriverVersion method.
|
|
SystemGetCudaDriverVersionFunc func() (int, nvml.Return)
|
|
|
|
// SystemGetCudaDriverVersion_v2Func mocks the SystemGetCudaDriverVersion_v2 method.
|
|
SystemGetCudaDriverVersion_v2Func func() (int, nvml.Return)
|
|
|
|
// SystemGetDriverVersionFunc mocks the SystemGetDriverVersion method.
|
|
SystemGetDriverVersionFunc func() (string, nvml.Return)
|
|
|
|
// SystemGetHicVersionFunc mocks the SystemGetHicVersion method.
|
|
SystemGetHicVersionFunc func() ([]nvml.HwbcEntry, nvml.Return)
|
|
|
|
// SystemGetNVMLVersionFunc mocks the SystemGetNVMLVersion method.
|
|
SystemGetNVMLVersionFunc func() (string, nvml.Return)
|
|
|
|
// SystemGetProcessNameFunc mocks the SystemGetProcessName method.
|
|
SystemGetProcessNameFunc func(n int) (string, nvml.Return)
|
|
|
|
// SystemGetTopologyGpuSetFunc mocks the SystemGetTopologyGpuSet method.
|
|
SystemGetTopologyGpuSetFunc func(n int) ([]nvml.Device, nvml.Return)
|
|
|
|
// UnitGetCountFunc mocks the UnitGetCount method.
|
|
UnitGetCountFunc func() (int, nvml.Return)
|
|
|
|
// UnitGetDevicesFunc mocks the UnitGetDevices method.
|
|
UnitGetDevicesFunc func(unit nvml.Unit) ([]nvml.Device, nvml.Return)
|
|
|
|
// UnitGetFanSpeedInfoFunc mocks the UnitGetFanSpeedInfo method.
|
|
UnitGetFanSpeedInfoFunc func(unit nvml.Unit) (nvml.UnitFanSpeeds, nvml.Return)
|
|
|
|
// UnitGetHandleByIndexFunc mocks the UnitGetHandleByIndex method.
|
|
UnitGetHandleByIndexFunc func(n int) (nvml.Unit, nvml.Return)
|
|
|
|
// UnitGetLedStateFunc mocks the UnitGetLedState method.
|
|
UnitGetLedStateFunc func(unit nvml.Unit) (nvml.LedState, nvml.Return)
|
|
|
|
// UnitGetPsuInfoFunc mocks the UnitGetPsuInfo method.
|
|
UnitGetPsuInfoFunc func(unit nvml.Unit) (nvml.PSUInfo, nvml.Return)
|
|
|
|
// UnitGetTemperatureFunc mocks the UnitGetTemperature method.
|
|
UnitGetTemperatureFunc func(unit nvml.Unit, n int) (uint32, nvml.Return)
|
|
|
|
// UnitGetUnitInfoFunc mocks the UnitGetUnitInfo method.
|
|
UnitGetUnitInfoFunc func(unit nvml.Unit) (nvml.UnitInfo, nvml.Return)
|
|
|
|
// UnitSetLedStateFunc mocks the UnitSetLedState method.
|
|
UnitSetLedStateFunc func(unit nvml.Unit, ledColor nvml.LedColor) nvml.Return
|
|
|
|
// VgpuInstanceClearAccountingPidsFunc mocks the VgpuInstanceClearAccountingPids method.
|
|
VgpuInstanceClearAccountingPidsFunc func(vgpuInstance nvml.VgpuInstance) nvml.Return
|
|
|
|
// VgpuInstanceGetAccountingModeFunc mocks the VgpuInstanceGetAccountingMode method.
|
|
VgpuInstanceGetAccountingModeFunc func(vgpuInstance nvml.VgpuInstance) (nvml.EnableState, nvml.Return)
|
|
|
|
// VgpuInstanceGetAccountingPidsFunc mocks the VgpuInstanceGetAccountingPids method.
|
|
VgpuInstanceGetAccountingPidsFunc func(vgpuInstance nvml.VgpuInstance) ([]int, nvml.Return)
|
|
|
|
// VgpuInstanceGetAccountingStatsFunc mocks the VgpuInstanceGetAccountingStats method.
|
|
VgpuInstanceGetAccountingStatsFunc func(vgpuInstance nvml.VgpuInstance, n int) (nvml.AccountingStats, nvml.Return)
|
|
|
|
// VgpuInstanceGetEccModeFunc mocks the VgpuInstanceGetEccMode method.
|
|
VgpuInstanceGetEccModeFunc func(vgpuInstance nvml.VgpuInstance) (nvml.EnableState, nvml.Return)
|
|
|
|
// VgpuInstanceGetEncoderCapacityFunc mocks the VgpuInstanceGetEncoderCapacity method.
|
|
VgpuInstanceGetEncoderCapacityFunc func(vgpuInstance nvml.VgpuInstance) (int, nvml.Return)
|
|
|
|
// VgpuInstanceGetEncoderSessionsFunc mocks the VgpuInstanceGetEncoderSessions method.
|
|
VgpuInstanceGetEncoderSessionsFunc func(vgpuInstance nvml.VgpuInstance) (int, nvml.EncoderSessionInfo, nvml.Return)
|
|
|
|
// VgpuInstanceGetEncoderStatsFunc mocks the VgpuInstanceGetEncoderStats method.
|
|
VgpuInstanceGetEncoderStatsFunc func(vgpuInstance nvml.VgpuInstance) (int, uint32, uint32, nvml.Return)
|
|
|
|
// VgpuInstanceGetFBCSessionsFunc mocks the VgpuInstanceGetFBCSessions method.
|
|
VgpuInstanceGetFBCSessionsFunc func(vgpuInstance nvml.VgpuInstance) (int, nvml.FBCSessionInfo, nvml.Return)
|
|
|
|
// VgpuInstanceGetFBCStatsFunc mocks the VgpuInstanceGetFBCStats method.
|
|
VgpuInstanceGetFBCStatsFunc func(vgpuInstance nvml.VgpuInstance) (nvml.FBCStats, nvml.Return)
|
|
|
|
// VgpuInstanceGetFbUsageFunc mocks the VgpuInstanceGetFbUsage method.
|
|
VgpuInstanceGetFbUsageFunc func(vgpuInstance nvml.VgpuInstance) (uint64, nvml.Return)
|
|
|
|
// VgpuInstanceGetFrameRateLimitFunc mocks the VgpuInstanceGetFrameRateLimit method.
|
|
VgpuInstanceGetFrameRateLimitFunc func(vgpuInstance nvml.VgpuInstance) (uint32, nvml.Return)
|
|
|
|
// VgpuInstanceGetGpuInstanceIdFunc mocks the VgpuInstanceGetGpuInstanceId method.
|
|
VgpuInstanceGetGpuInstanceIdFunc func(vgpuInstance nvml.VgpuInstance) (int, nvml.Return)
|
|
|
|
// VgpuInstanceGetGpuPciIdFunc mocks the VgpuInstanceGetGpuPciId method.
|
|
VgpuInstanceGetGpuPciIdFunc func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return)
|
|
|
|
// VgpuInstanceGetLicenseInfoFunc mocks the VgpuInstanceGetLicenseInfo method.
|
|
VgpuInstanceGetLicenseInfoFunc func(vgpuInstance nvml.VgpuInstance) (nvml.VgpuLicenseInfo, nvml.Return)
|
|
|
|
// VgpuInstanceGetLicenseStatusFunc mocks the VgpuInstanceGetLicenseStatus method.
|
|
VgpuInstanceGetLicenseStatusFunc func(vgpuInstance nvml.VgpuInstance) (int, nvml.Return)
|
|
|
|
// VgpuInstanceGetMdevUUIDFunc mocks the VgpuInstanceGetMdevUUID method.
|
|
VgpuInstanceGetMdevUUIDFunc func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return)
|
|
|
|
// VgpuInstanceGetMetadataFunc mocks the VgpuInstanceGetMetadata method.
|
|
VgpuInstanceGetMetadataFunc func(vgpuInstance nvml.VgpuInstance) (nvml.VgpuMetadata, nvml.Return)
|
|
|
|
// VgpuInstanceGetTypeFunc mocks the VgpuInstanceGetType method.
|
|
VgpuInstanceGetTypeFunc func(vgpuInstance nvml.VgpuInstance) (nvml.VgpuTypeId, nvml.Return)
|
|
|
|
// VgpuInstanceGetUUIDFunc mocks the VgpuInstanceGetUUID method.
|
|
VgpuInstanceGetUUIDFunc func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return)
|
|
|
|
// VgpuInstanceGetVmDriverVersionFunc mocks the VgpuInstanceGetVmDriverVersion method.
|
|
VgpuInstanceGetVmDriverVersionFunc func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return)
|
|
|
|
// VgpuInstanceGetVmIDFunc mocks the VgpuInstanceGetVmID method.
|
|
VgpuInstanceGetVmIDFunc func(vgpuInstance nvml.VgpuInstance) (string, nvml.VgpuVmIdType, nvml.Return)
|
|
|
|
// VgpuInstanceSetEncoderCapacityFunc mocks the VgpuInstanceSetEncoderCapacity method.
|
|
VgpuInstanceSetEncoderCapacityFunc func(vgpuInstance nvml.VgpuInstance, n int) nvml.Return
|
|
|
|
// VgpuTypeGetCapabilitiesFunc mocks the VgpuTypeGetCapabilities method.
|
|
VgpuTypeGetCapabilitiesFunc func(vgpuTypeId nvml.VgpuTypeId, vgpuCapability nvml.VgpuCapability) (bool, nvml.Return)
|
|
|
|
// VgpuTypeGetClassFunc mocks the VgpuTypeGetClass method.
|
|
VgpuTypeGetClassFunc func(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return)
|
|
|
|
// VgpuTypeGetDeviceIDFunc mocks the VgpuTypeGetDeviceID method.
|
|
VgpuTypeGetDeviceIDFunc func(vgpuTypeId nvml.VgpuTypeId) (uint64, uint64, nvml.Return)
|
|
|
|
// VgpuTypeGetFrameRateLimitFunc mocks the VgpuTypeGetFrameRateLimit method.
|
|
VgpuTypeGetFrameRateLimitFunc func(vgpuTypeId nvml.VgpuTypeId) (uint32, nvml.Return)
|
|
|
|
// VgpuTypeGetFramebufferSizeFunc mocks the VgpuTypeGetFramebufferSize method.
|
|
VgpuTypeGetFramebufferSizeFunc func(vgpuTypeId nvml.VgpuTypeId) (uint64, nvml.Return)
|
|
|
|
// VgpuTypeGetGpuInstanceProfileIdFunc mocks the VgpuTypeGetGpuInstanceProfileId method.
|
|
VgpuTypeGetGpuInstanceProfileIdFunc func(vgpuTypeId nvml.VgpuTypeId) (uint32, nvml.Return)
|
|
|
|
// VgpuTypeGetLicenseFunc mocks the VgpuTypeGetLicense method.
|
|
VgpuTypeGetLicenseFunc func(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return)
|
|
|
|
// VgpuTypeGetMaxInstancesFunc mocks the VgpuTypeGetMaxInstances method.
|
|
VgpuTypeGetMaxInstancesFunc func(device nvml.Device, vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return)
|
|
|
|
// VgpuTypeGetMaxInstancesPerVmFunc mocks the VgpuTypeGetMaxInstancesPerVm method.
|
|
VgpuTypeGetMaxInstancesPerVmFunc func(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return)
|
|
|
|
// VgpuTypeGetNameFunc mocks the VgpuTypeGetName method.
|
|
VgpuTypeGetNameFunc func(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return)
|
|
|
|
// VgpuTypeGetNumDisplayHeadsFunc mocks the VgpuTypeGetNumDisplayHeads method.
|
|
VgpuTypeGetNumDisplayHeadsFunc func(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return)
|
|
|
|
// VgpuTypeGetResolutionFunc mocks the VgpuTypeGetResolution method.
|
|
VgpuTypeGetResolutionFunc func(vgpuTypeId nvml.VgpuTypeId, n int) (uint32, uint32, nvml.Return)
|
|
|
|
// calls tracks calls to the methods.
|
|
calls struct {
|
|
// ComputeInstanceDestroy holds details about calls to the ComputeInstanceDestroy method.
|
|
ComputeInstanceDestroy []struct {
|
|
// ComputeInstance is the computeInstance argument value.
|
|
ComputeInstance nvml.ComputeInstance
|
|
}
|
|
// ComputeInstanceGetInfo holds details about calls to the ComputeInstanceGetInfo method.
|
|
ComputeInstanceGetInfo []struct {
|
|
// ComputeInstance is the computeInstance argument value.
|
|
ComputeInstance nvml.ComputeInstance
|
|
}
|
|
// DeviceCcuGetStreamState holds details about calls to the DeviceCcuGetStreamState method.
|
|
DeviceCcuGetStreamState []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceCcuSetStreamState holds details about calls to the DeviceCcuSetStreamState method.
|
|
DeviceCcuSetStreamState []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceClearAccountingPids holds details about calls to the DeviceClearAccountingPids method.
|
|
DeviceClearAccountingPids []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceClearCpuAffinity holds details about calls to the DeviceClearCpuAffinity method.
|
|
DeviceClearCpuAffinity []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceClearEccErrorCounts holds details about calls to the DeviceClearEccErrorCounts method.
|
|
DeviceClearEccErrorCounts []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// EccCounterType is the eccCounterType argument value.
|
|
EccCounterType nvml.EccCounterType
|
|
}
|
|
// DeviceClearFieldValues holds details about calls to the DeviceClearFieldValues method.
|
|
DeviceClearFieldValues []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// FieldValues is the fieldValues argument value.
|
|
FieldValues []nvml.FieldValue
|
|
}
|
|
// DeviceCreateGpuInstance holds details about calls to the DeviceCreateGpuInstance method.
|
|
DeviceCreateGpuInstance []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
// DeviceCreateGpuInstanceWithPlacement holds details about calls to the DeviceCreateGpuInstanceWithPlacement method.
|
|
DeviceCreateGpuInstanceWithPlacement []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
// GpuInstancePlacement is the gpuInstancePlacement argument value.
|
|
GpuInstancePlacement *nvml.GpuInstancePlacement
|
|
}
|
|
// DeviceDiscoverGpus holds details about calls to the DeviceDiscoverGpus method.
|
|
DeviceDiscoverGpus []struct {
|
|
}
|
|
// DeviceFreezeNvLinkUtilizationCounter holds details about calls to the DeviceFreezeNvLinkUtilizationCounter method.
|
|
DeviceFreezeNvLinkUtilizationCounter []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N1 is the n1 argument value.
|
|
N1 int
|
|
// N2 is the n2 argument value.
|
|
N2 int
|
|
// EnableState is the enableState argument value.
|
|
EnableState nvml.EnableState
|
|
}
|
|
// DeviceGetAPIRestriction holds details about calls to the DeviceGetAPIRestriction method.
|
|
DeviceGetAPIRestriction []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// RestrictedAPI is the restrictedAPI argument value.
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
}
|
|
// DeviceGetAccountingBufferSize holds details about calls to the DeviceGetAccountingBufferSize method.
|
|
DeviceGetAccountingBufferSize []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetAccountingMode holds details about calls to the DeviceGetAccountingMode method.
|
|
DeviceGetAccountingMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetAccountingPids holds details about calls to the DeviceGetAccountingPids method.
|
|
DeviceGetAccountingPids []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetAccountingStats holds details about calls to the DeviceGetAccountingStats method.
|
|
DeviceGetAccountingStats []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// V is the v argument value.
|
|
V uint32
|
|
}
|
|
// DeviceGetActiveVgpus holds details about calls to the DeviceGetActiveVgpus method.
|
|
DeviceGetActiveVgpus []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetAdaptiveClockInfoStatus holds details about calls to the DeviceGetAdaptiveClockInfoStatus method.
|
|
DeviceGetAdaptiveClockInfoStatus []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetApplicationsClock holds details about calls to the DeviceGetApplicationsClock method.
|
|
DeviceGetApplicationsClock []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// ClockType is the clockType argument value.
|
|
ClockType nvml.ClockType
|
|
}
|
|
// DeviceGetArchitecture holds details about calls to the DeviceGetArchitecture method.
|
|
DeviceGetArchitecture []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetAttributes holds details about calls to the DeviceGetAttributes method.
|
|
DeviceGetAttributes []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetAutoBoostedClocksEnabled holds details about calls to the DeviceGetAutoBoostedClocksEnabled method.
|
|
DeviceGetAutoBoostedClocksEnabled []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetBAR1MemoryInfo holds details about calls to the DeviceGetBAR1MemoryInfo method.
|
|
DeviceGetBAR1MemoryInfo []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetBoardId holds details about calls to the DeviceGetBoardId method.
|
|
DeviceGetBoardId []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetBoardPartNumber holds details about calls to the DeviceGetBoardPartNumber method.
|
|
DeviceGetBoardPartNumber []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetBrand holds details about calls to the DeviceGetBrand method.
|
|
DeviceGetBrand []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetBridgeChipInfo holds details about calls to the DeviceGetBridgeChipInfo method.
|
|
DeviceGetBridgeChipInfo []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetBusType holds details about calls to the DeviceGetBusType method.
|
|
DeviceGetBusType []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetClkMonStatus holds details about calls to the DeviceGetClkMonStatus method.
|
|
DeviceGetClkMonStatus []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetClock holds details about calls to the DeviceGetClock method.
|
|
DeviceGetClock []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// ClockType is the clockType argument value.
|
|
ClockType nvml.ClockType
|
|
// ClockId is the clockId argument value.
|
|
ClockId nvml.ClockId
|
|
}
|
|
// DeviceGetClockInfo holds details about calls to the DeviceGetClockInfo method.
|
|
DeviceGetClockInfo []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// ClockType is the clockType argument value.
|
|
ClockType nvml.ClockType
|
|
}
|
|
// DeviceGetComputeInstanceId holds details about calls to the DeviceGetComputeInstanceId method.
|
|
DeviceGetComputeInstanceId []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetComputeMode holds details about calls to the DeviceGetComputeMode method.
|
|
DeviceGetComputeMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetComputeRunningProcesses holds details about calls to the DeviceGetComputeRunningProcesses method.
|
|
DeviceGetComputeRunningProcesses []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetCount holds details about calls to the DeviceGetCount method.
|
|
DeviceGetCount []struct {
|
|
}
|
|
// DeviceGetCpuAffinity holds details about calls to the DeviceGetCpuAffinity method.
|
|
DeviceGetCpuAffinity []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceGetCpuAffinityWithinScope holds details about calls to the DeviceGetCpuAffinityWithinScope method.
|
|
DeviceGetCpuAffinityWithinScope []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
// AffinityScope is the affinityScope argument value.
|
|
AffinityScope nvml.AffinityScope
|
|
}
|
|
// DeviceGetCreatableVgpus holds details about calls to the DeviceGetCreatableVgpus method.
|
|
DeviceGetCreatableVgpus []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetCudaComputeCapability holds details about calls to the DeviceGetCudaComputeCapability method.
|
|
DeviceGetCudaComputeCapability []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetCurrPcieLinkGeneration holds details about calls to the DeviceGetCurrPcieLinkGeneration method.
|
|
DeviceGetCurrPcieLinkGeneration []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetCurrPcieLinkWidth holds details about calls to the DeviceGetCurrPcieLinkWidth method.
|
|
DeviceGetCurrPcieLinkWidth []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetCurrentClocksThrottleReasons holds details about calls to the DeviceGetCurrentClocksThrottleReasons method.
|
|
DeviceGetCurrentClocksThrottleReasons []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetDecoderUtilization holds details about calls to the DeviceGetDecoderUtilization method.
|
|
DeviceGetDecoderUtilization []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetDefaultApplicationsClock holds details about calls to the DeviceGetDefaultApplicationsClock method.
|
|
DeviceGetDefaultApplicationsClock []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// ClockType is the clockType argument value.
|
|
ClockType nvml.ClockType
|
|
}
|
|
// DeviceGetDefaultEccMode holds details about calls to the DeviceGetDefaultEccMode method.
|
|
DeviceGetDefaultEccMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetDetailedEccErrors holds details about calls to the DeviceGetDetailedEccErrors method.
|
|
DeviceGetDetailedEccErrors []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// MemoryErrorType is the memoryErrorType argument value.
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
// EccCounterType is the eccCounterType argument value.
|
|
EccCounterType nvml.EccCounterType
|
|
}
|
|
// DeviceGetDeviceHandleFromMigDeviceHandle holds details about calls to the DeviceGetDeviceHandleFromMigDeviceHandle method.
|
|
DeviceGetDeviceHandleFromMigDeviceHandle []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetDisplayActive holds details about calls to the DeviceGetDisplayActive method.
|
|
DeviceGetDisplayActive []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetDisplayMode holds details about calls to the DeviceGetDisplayMode method.
|
|
DeviceGetDisplayMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetDriverModel holds details about calls to the DeviceGetDriverModel method.
|
|
DeviceGetDriverModel []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetDynamicPstatesInfo holds details about calls to the DeviceGetDynamicPstatesInfo method.
|
|
DeviceGetDynamicPstatesInfo []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetEccMode holds details about calls to the DeviceGetEccMode method.
|
|
DeviceGetEccMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetEncoderCapacity holds details about calls to the DeviceGetEncoderCapacity method.
|
|
DeviceGetEncoderCapacity []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// EncoderType is the encoderType argument value.
|
|
EncoderType nvml.EncoderType
|
|
}
|
|
// DeviceGetEncoderSessions holds details about calls to the DeviceGetEncoderSessions method.
|
|
DeviceGetEncoderSessions []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetEncoderStats holds details about calls to the DeviceGetEncoderStats method.
|
|
DeviceGetEncoderStats []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetEncoderUtilization holds details about calls to the DeviceGetEncoderUtilization method.
|
|
DeviceGetEncoderUtilization []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetEnforcedPowerLimit holds details about calls to the DeviceGetEnforcedPowerLimit method.
|
|
DeviceGetEnforcedPowerLimit []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetFBCSessions holds details about calls to the DeviceGetFBCSessions method.
|
|
DeviceGetFBCSessions []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetFBCStats holds details about calls to the DeviceGetFBCStats method.
|
|
DeviceGetFBCStats []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetFanControlPolicy_v2 holds details about calls to the DeviceGetFanControlPolicy_v2 method.
|
|
DeviceGetFanControlPolicy_v2 []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceGetFanSpeed holds details about calls to the DeviceGetFanSpeed method.
|
|
DeviceGetFanSpeed []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetFanSpeed_v2 holds details about calls to the DeviceGetFanSpeed_v2 method.
|
|
DeviceGetFanSpeed_v2 []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceGetFieldValues holds details about calls to the DeviceGetFieldValues method.
|
|
DeviceGetFieldValues []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// FieldValues is the fieldValues argument value.
|
|
FieldValues []nvml.FieldValue
|
|
}
|
|
// DeviceGetGpcClkMinMaxVfOffset holds details about calls to the DeviceGetGpcClkMinMaxVfOffset method.
|
|
DeviceGetGpcClkMinMaxVfOffset []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetGpcClkVfOffset holds details about calls to the DeviceGetGpcClkVfOffset method.
|
|
DeviceGetGpcClkVfOffset []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetGpuFabricInfo holds details about calls to the DeviceGetGpuFabricInfo method.
|
|
DeviceGetGpuFabricInfo []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetGpuInstanceById holds details about calls to the DeviceGetGpuInstanceById method.
|
|
DeviceGetGpuInstanceById []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceGetGpuInstanceId holds details about calls to the DeviceGetGpuInstanceId method.
|
|
DeviceGetGpuInstanceId []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetGpuInstancePossiblePlacements holds details about calls to the DeviceGetGpuInstancePossiblePlacements method.
|
|
DeviceGetGpuInstancePossiblePlacements []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
// DeviceGetGpuInstanceProfileInfo holds details about calls to the DeviceGetGpuInstanceProfileInfo method.
|
|
DeviceGetGpuInstanceProfileInfo []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceGetGpuInstanceProfileInfoV holds details about calls to the DeviceGetGpuInstanceProfileInfoV method.
|
|
DeviceGetGpuInstanceProfileInfoV []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceGetGpuInstanceRemainingCapacity holds details about calls to the DeviceGetGpuInstanceRemainingCapacity method.
|
|
DeviceGetGpuInstanceRemainingCapacity []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
// DeviceGetGpuInstances holds details about calls to the DeviceGetGpuInstances method.
|
|
DeviceGetGpuInstances []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
// DeviceGetGpuMaxPcieLinkGeneration holds details about calls to the DeviceGetGpuMaxPcieLinkGeneration method.
|
|
DeviceGetGpuMaxPcieLinkGeneration []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetGpuOperationMode holds details about calls to the DeviceGetGpuOperationMode method.
|
|
DeviceGetGpuOperationMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetGraphicsRunningProcesses holds details about calls to the DeviceGetGraphicsRunningProcesses method.
|
|
DeviceGetGraphicsRunningProcesses []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetGridLicensableFeatures holds details about calls to the DeviceGetGridLicensableFeatures method.
|
|
DeviceGetGridLicensableFeatures []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetGspFirmwareMode holds details about calls to the DeviceGetGspFirmwareMode method.
|
|
DeviceGetGspFirmwareMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetGspFirmwareVersion holds details about calls to the DeviceGetGspFirmwareVersion method.
|
|
DeviceGetGspFirmwareVersion []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetHandleByIndex holds details about calls to the DeviceGetHandleByIndex method.
|
|
DeviceGetHandleByIndex []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceGetHandleByPciBusId holds details about calls to the DeviceGetHandleByPciBusId method.
|
|
DeviceGetHandleByPciBusId []struct {
|
|
// S is the s argument value.
|
|
S string
|
|
}
|
|
// DeviceGetHandleBySerial holds details about calls to the DeviceGetHandleBySerial method.
|
|
DeviceGetHandleBySerial []struct {
|
|
// S is the s argument value.
|
|
S string
|
|
}
|
|
// DeviceGetHandleByUUID holds details about calls to the DeviceGetHandleByUUID method.
|
|
DeviceGetHandleByUUID []struct {
|
|
// S is the s argument value.
|
|
S string
|
|
}
|
|
// DeviceGetHostVgpuMode holds details about calls to the DeviceGetHostVgpuMode method.
|
|
DeviceGetHostVgpuMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetIndex holds details about calls to the DeviceGetIndex method.
|
|
DeviceGetIndex []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetInforomConfigurationChecksum holds details about calls to the DeviceGetInforomConfigurationChecksum method.
|
|
DeviceGetInforomConfigurationChecksum []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetInforomImageVersion holds details about calls to the DeviceGetInforomImageVersion method.
|
|
DeviceGetInforomImageVersion []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetInforomVersion holds details about calls to the DeviceGetInforomVersion method.
|
|
DeviceGetInforomVersion []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// InforomObject is the inforomObject argument value.
|
|
InforomObject nvml.InforomObject
|
|
}
|
|
// DeviceGetIrqNum holds details about calls to the DeviceGetIrqNum method.
|
|
DeviceGetIrqNum []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetMPSComputeRunningProcesses holds details about calls to the DeviceGetMPSComputeRunningProcesses method.
|
|
DeviceGetMPSComputeRunningProcesses []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetMaxClockInfo holds details about calls to the DeviceGetMaxClockInfo method.
|
|
DeviceGetMaxClockInfo []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// ClockType is the clockType argument value.
|
|
ClockType nvml.ClockType
|
|
}
|
|
// DeviceGetMaxCustomerBoostClock holds details about calls to the DeviceGetMaxCustomerBoostClock method.
|
|
DeviceGetMaxCustomerBoostClock []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// ClockType is the clockType argument value.
|
|
ClockType nvml.ClockType
|
|
}
|
|
// DeviceGetMaxMigDeviceCount holds details about calls to the DeviceGetMaxMigDeviceCount method.
|
|
DeviceGetMaxMigDeviceCount []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetMaxPcieLinkGeneration holds details about calls to the DeviceGetMaxPcieLinkGeneration method.
|
|
DeviceGetMaxPcieLinkGeneration []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetMaxPcieLinkWidth holds details about calls to the DeviceGetMaxPcieLinkWidth method.
|
|
DeviceGetMaxPcieLinkWidth []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetMemClkMinMaxVfOffset holds details about calls to the DeviceGetMemClkMinMaxVfOffset method.
|
|
DeviceGetMemClkMinMaxVfOffset []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetMemClkVfOffset holds details about calls to the DeviceGetMemClkVfOffset method.
|
|
DeviceGetMemClkVfOffset []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetMemoryAffinity holds details about calls to the DeviceGetMemoryAffinity method.
|
|
DeviceGetMemoryAffinity []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
// AffinityScope is the affinityScope argument value.
|
|
AffinityScope nvml.AffinityScope
|
|
}
|
|
// DeviceGetMemoryBusWidth holds details about calls to the DeviceGetMemoryBusWidth method.
|
|
DeviceGetMemoryBusWidth []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetMemoryErrorCounter holds details about calls to the DeviceGetMemoryErrorCounter method.
|
|
DeviceGetMemoryErrorCounter []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// MemoryErrorType is the memoryErrorType argument value.
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
// EccCounterType is the eccCounterType argument value.
|
|
EccCounterType nvml.EccCounterType
|
|
// MemoryLocation is the memoryLocation argument value.
|
|
MemoryLocation nvml.MemoryLocation
|
|
}
|
|
// DeviceGetMemoryInfo holds details about calls to the DeviceGetMemoryInfo method.
|
|
DeviceGetMemoryInfo []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetMemoryInfo_v2 holds details about calls to the DeviceGetMemoryInfo_v2 method.
|
|
DeviceGetMemoryInfo_v2 []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetMigDeviceHandleByIndex holds details about calls to the DeviceGetMigDeviceHandleByIndex method.
|
|
DeviceGetMigDeviceHandleByIndex []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceGetMigMode holds details about calls to the DeviceGetMigMode method.
|
|
DeviceGetMigMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetMinMaxClockOfPState holds details about calls to the DeviceGetMinMaxClockOfPState method.
|
|
DeviceGetMinMaxClockOfPState []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// ClockType is the clockType argument value.
|
|
ClockType nvml.ClockType
|
|
// Pstates is the pstates argument value.
|
|
Pstates nvml.Pstates
|
|
}
|
|
// DeviceGetMinMaxFanSpeed holds details about calls to the DeviceGetMinMaxFanSpeed method.
|
|
DeviceGetMinMaxFanSpeed []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetMinorNumber holds details about calls to the DeviceGetMinorNumber method.
|
|
DeviceGetMinorNumber []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetMultiGpuBoard holds details about calls to the DeviceGetMultiGpuBoard method.
|
|
DeviceGetMultiGpuBoard []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetName holds details about calls to the DeviceGetName method.
|
|
DeviceGetName []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetNumFans holds details about calls to the DeviceGetNumFans method.
|
|
DeviceGetNumFans []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetNumGpuCores holds details about calls to the DeviceGetNumGpuCores method.
|
|
DeviceGetNumGpuCores []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetNvLinkCapability holds details about calls to the DeviceGetNvLinkCapability method.
|
|
DeviceGetNvLinkCapability []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
// NvLinkCapability is the nvLinkCapability argument value.
|
|
NvLinkCapability nvml.NvLinkCapability
|
|
}
|
|
// DeviceGetNvLinkErrorCounter holds details about calls to the DeviceGetNvLinkErrorCounter method.
|
|
DeviceGetNvLinkErrorCounter []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
// NvLinkErrorCounter is the nvLinkErrorCounter argument value.
|
|
NvLinkErrorCounter nvml.NvLinkErrorCounter
|
|
}
|
|
// DeviceGetNvLinkRemoteDeviceType holds details about calls to the DeviceGetNvLinkRemoteDeviceType method.
|
|
DeviceGetNvLinkRemoteDeviceType []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceGetNvLinkRemotePciInfo holds details about calls to the DeviceGetNvLinkRemotePciInfo method.
|
|
DeviceGetNvLinkRemotePciInfo []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceGetNvLinkState holds details about calls to the DeviceGetNvLinkState method.
|
|
DeviceGetNvLinkState []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceGetNvLinkUtilizationControl holds details about calls to the DeviceGetNvLinkUtilizationControl method.
|
|
DeviceGetNvLinkUtilizationControl []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N1 is the n1 argument value.
|
|
N1 int
|
|
// N2 is the n2 argument value.
|
|
N2 int
|
|
}
|
|
// DeviceGetNvLinkUtilizationCounter holds details about calls to the DeviceGetNvLinkUtilizationCounter method.
|
|
DeviceGetNvLinkUtilizationCounter []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N1 is the n1 argument value.
|
|
N1 int
|
|
// N2 is the n2 argument value.
|
|
N2 int
|
|
}
|
|
// DeviceGetNvLinkVersion holds details about calls to the DeviceGetNvLinkVersion method.
|
|
DeviceGetNvLinkVersion []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceGetP2PStatus holds details about calls to the DeviceGetP2PStatus method.
|
|
DeviceGetP2PStatus []struct {
|
|
// Device1 is the device1 argument value.
|
|
Device1 nvml.Device
|
|
// Device2 is the device2 argument value.
|
|
Device2 nvml.Device
|
|
// GpuP2PCapsIndex is the gpuP2PCapsIndex argument value.
|
|
GpuP2PCapsIndex nvml.GpuP2PCapsIndex
|
|
}
|
|
// DeviceGetPciInfo holds details about calls to the DeviceGetPciInfo method.
|
|
DeviceGetPciInfo []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetPcieLinkMaxSpeed holds details about calls to the DeviceGetPcieLinkMaxSpeed method.
|
|
DeviceGetPcieLinkMaxSpeed []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetPcieReplayCounter holds details about calls to the DeviceGetPcieReplayCounter method.
|
|
DeviceGetPcieReplayCounter []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetPcieSpeed holds details about calls to the DeviceGetPcieSpeed method.
|
|
DeviceGetPcieSpeed []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetPcieThroughput holds details about calls to the DeviceGetPcieThroughput method.
|
|
DeviceGetPcieThroughput []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// PcieUtilCounter is the pcieUtilCounter argument value.
|
|
PcieUtilCounter nvml.PcieUtilCounter
|
|
}
|
|
// DeviceGetPerformanceState holds details about calls to the DeviceGetPerformanceState method.
|
|
DeviceGetPerformanceState []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetPersistenceMode holds details about calls to the DeviceGetPersistenceMode method.
|
|
DeviceGetPersistenceMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetPgpuMetadataString holds details about calls to the DeviceGetPgpuMetadataString method.
|
|
DeviceGetPgpuMetadataString []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetPowerManagementDefaultLimit holds details about calls to the DeviceGetPowerManagementDefaultLimit method.
|
|
DeviceGetPowerManagementDefaultLimit []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetPowerManagementLimit holds details about calls to the DeviceGetPowerManagementLimit method.
|
|
DeviceGetPowerManagementLimit []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetPowerManagementLimitConstraints holds details about calls to the DeviceGetPowerManagementLimitConstraints method.
|
|
DeviceGetPowerManagementLimitConstraints []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetPowerManagementMode holds details about calls to the DeviceGetPowerManagementMode method.
|
|
DeviceGetPowerManagementMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetPowerSource holds details about calls to the DeviceGetPowerSource method.
|
|
DeviceGetPowerSource []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetPowerState holds details about calls to the DeviceGetPowerState method.
|
|
DeviceGetPowerState []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetPowerUsage holds details about calls to the DeviceGetPowerUsage method.
|
|
DeviceGetPowerUsage []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetProcessUtilization holds details about calls to the DeviceGetProcessUtilization method.
|
|
DeviceGetProcessUtilization []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// V is the v argument value.
|
|
V uint64
|
|
}
|
|
// DeviceGetRemappedRows holds details about calls to the DeviceGetRemappedRows method.
|
|
DeviceGetRemappedRows []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetRetiredPages holds details about calls to the DeviceGetRetiredPages method.
|
|
DeviceGetRetiredPages []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// PageRetirementCause is the pageRetirementCause argument value.
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
}
|
|
// DeviceGetRetiredPagesPendingStatus holds details about calls to the DeviceGetRetiredPagesPendingStatus method.
|
|
DeviceGetRetiredPagesPendingStatus []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetRetiredPages_v2 holds details about calls to the DeviceGetRetiredPages_v2 method.
|
|
DeviceGetRetiredPages_v2 []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// PageRetirementCause is the pageRetirementCause argument value.
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
}
|
|
// DeviceGetRowRemapperHistogram holds details about calls to the DeviceGetRowRemapperHistogram method.
|
|
DeviceGetRowRemapperHistogram []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetSamples holds details about calls to the DeviceGetSamples method.
|
|
DeviceGetSamples []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// SamplingType is the samplingType argument value.
|
|
SamplingType nvml.SamplingType
|
|
// V is the v argument value.
|
|
V uint64
|
|
}
|
|
// DeviceGetSerial holds details about calls to the DeviceGetSerial method.
|
|
DeviceGetSerial []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetSupportedClocksThrottleReasons holds details about calls to the DeviceGetSupportedClocksThrottleReasons method.
|
|
DeviceGetSupportedClocksThrottleReasons []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetSupportedEventTypes holds details about calls to the DeviceGetSupportedEventTypes method.
|
|
DeviceGetSupportedEventTypes []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetSupportedGraphicsClocks holds details about calls to the DeviceGetSupportedGraphicsClocks method.
|
|
DeviceGetSupportedGraphicsClocks []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceGetSupportedMemoryClocks holds details about calls to the DeviceGetSupportedMemoryClocks method.
|
|
DeviceGetSupportedMemoryClocks []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetSupportedPerformanceStates holds details about calls to the DeviceGetSupportedPerformanceStates method.
|
|
DeviceGetSupportedPerformanceStates []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetSupportedVgpus holds details about calls to the DeviceGetSupportedVgpus method.
|
|
DeviceGetSupportedVgpus []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetTargetFanSpeed holds details about calls to the DeviceGetTargetFanSpeed method.
|
|
DeviceGetTargetFanSpeed []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceGetTemperature holds details about calls to the DeviceGetTemperature method.
|
|
DeviceGetTemperature []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// TemperatureSensors is the temperatureSensors argument value.
|
|
TemperatureSensors nvml.TemperatureSensors
|
|
}
|
|
// DeviceGetTemperatureThreshold holds details about calls to the DeviceGetTemperatureThreshold method.
|
|
DeviceGetTemperatureThreshold []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// TemperatureThresholds is the temperatureThresholds argument value.
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
}
|
|
// DeviceGetThermalSettings holds details about calls to the DeviceGetThermalSettings method.
|
|
DeviceGetThermalSettings []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// V is the v argument value.
|
|
V uint32
|
|
}
|
|
// DeviceGetTopologyCommonAncestor holds details about calls to the DeviceGetTopologyCommonAncestor method.
|
|
DeviceGetTopologyCommonAncestor []struct {
|
|
// Device1 is the device1 argument value.
|
|
Device1 nvml.Device
|
|
// Device2 is the device2 argument value.
|
|
Device2 nvml.Device
|
|
}
|
|
// DeviceGetTopologyNearestGpus holds details about calls to the DeviceGetTopologyNearestGpus method.
|
|
DeviceGetTopologyNearestGpus []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// GpuTopologyLevel is the gpuTopologyLevel argument value.
|
|
GpuTopologyLevel nvml.GpuTopologyLevel
|
|
}
|
|
// DeviceGetTotalEccErrors holds details about calls to the DeviceGetTotalEccErrors method.
|
|
DeviceGetTotalEccErrors []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// MemoryErrorType is the memoryErrorType argument value.
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
// EccCounterType is the eccCounterType argument value.
|
|
EccCounterType nvml.EccCounterType
|
|
}
|
|
// DeviceGetTotalEnergyConsumption holds details about calls to the DeviceGetTotalEnergyConsumption method.
|
|
DeviceGetTotalEnergyConsumption []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetUUID holds details about calls to the DeviceGetUUID method.
|
|
DeviceGetUUID []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetUtilizationRates holds details about calls to the DeviceGetUtilizationRates method.
|
|
DeviceGetUtilizationRates []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetVbiosVersion holds details about calls to the DeviceGetVbiosVersion method.
|
|
DeviceGetVbiosVersion []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetVgpuCapabilities holds details about calls to the DeviceGetVgpuCapabilities method.
|
|
DeviceGetVgpuCapabilities []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// DeviceVgpuCapability is the deviceVgpuCapability argument value.
|
|
DeviceVgpuCapability nvml.DeviceVgpuCapability
|
|
}
|
|
// DeviceGetVgpuMetadata holds details about calls to the DeviceGetVgpuMetadata method.
|
|
DeviceGetVgpuMetadata []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetVgpuProcessUtilization holds details about calls to the DeviceGetVgpuProcessUtilization method.
|
|
DeviceGetVgpuProcessUtilization []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// V is the v argument value.
|
|
V uint64
|
|
}
|
|
// DeviceGetVgpuSchedulerCapabilities holds details about calls to the DeviceGetVgpuSchedulerCapabilities method.
|
|
DeviceGetVgpuSchedulerCapabilities []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetVgpuSchedulerLog holds details about calls to the DeviceGetVgpuSchedulerLog method.
|
|
DeviceGetVgpuSchedulerLog []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetVgpuSchedulerState holds details about calls to the DeviceGetVgpuSchedulerState method.
|
|
DeviceGetVgpuSchedulerState []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceGetVgpuUtilization holds details about calls to the DeviceGetVgpuUtilization method.
|
|
DeviceGetVgpuUtilization []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// V is the v argument value.
|
|
V uint64
|
|
}
|
|
// DeviceGetViolationStatus holds details about calls to the DeviceGetViolationStatus method.
|
|
DeviceGetViolationStatus []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// PerfPolicyType is the perfPolicyType argument value.
|
|
PerfPolicyType nvml.PerfPolicyType
|
|
}
|
|
// DeviceGetVirtualizationMode holds details about calls to the DeviceGetVirtualizationMode method.
|
|
DeviceGetVirtualizationMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceIsMigDeviceHandle holds details about calls to the DeviceIsMigDeviceHandle method.
|
|
DeviceIsMigDeviceHandle []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceModifyDrainState holds details about calls to the DeviceModifyDrainState method.
|
|
DeviceModifyDrainState []struct {
|
|
// PciInfo is the pciInfo argument value.
|
|
PciInfo *nvml.PciInfo
|
|
// EnableState is the enableState argument value.
|
|
EnableState nvml.EnableState
|
|
}
|
|
// DeviceOnSameBoard holds details about calls to the DeviceOnSameBoard method.
|
|
DeviceOnSameBoard []struct {
|
|
// Device1 is the device1 argument value.
|
|
Device1 nvml.Device
|
|
// Device2 is the device2 argument value.
|
|
Device2 nvml.Device
|
|
}
|
|
// DeviceQueryDrainState holds details about calls to the DeviceQueryDrainState method.
|
|
DeviceQueryDrainState []struct {
|
|
// PciInfo is the pciInfo argument value.
|
|
PciInfo *nvml.PciInfo
|
|
}
|
|
// DeviceRegisterEvents holds details about calls to the DeviceRegisterEvents method.
|
|
DeviceRegisterEvents []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// V is the v argument value.
|
|
V uint64
|
|
// EventSet is the eventSet argument value.
|
|
EventSet nvml.EventSet
|
|
}
|
|
// DeviceRemoveGpu holds details about calls to the DeviceRemoveGpu method.
|
|
DeviceRemoveGpu []struct {
|
|
// PciInfo is the pciInfo argument value.
|
|
PciInfo *nvml.PciInfo
|
|
}
|
|
// DeviceRemoveGpu_v2 holds details about calls to the DeviceRemoveGpu_v2 method.
|
|
DeviceRemoveGpu_v2 []struct {
|
|
// PciInfo is the pciInfo argument value.
|
|
PciInfo *nvml.PciInfo
|
|
// DetachGpuState is the detachGpuState argument value.
|
|
DetachGpuState nvml.DetachGpuState
|
|
// PcieLinkState is the pcieLinkState argument value.
|
|
PcieLinkState nvml.PcieLinkState
|
|
}
|
|
// DeviceResetApplicationsClocks holds details about calls to the DeviceResetApplicationsClocks method.
|
|
DeviceResetApplicationsClocks []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceResetGpuLockedClocks holds details about calls to the DeviceResetGpuLockedClocks method.
|
|
DeviceResetGpuLockedClocks []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceResetMemoryLockedClocks holds details about calls to the DeviceResetMemoryLockedClocks method.
|
|
DeviceResetMemoryLockedClocks []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceResetNvLinkErrorCounters holds details about calls to the DeviceResetNvLinkErrorCounters method.
|
|
DeviceResetNvLinkErrorCounters []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceResetNvLinkUtilizationCounter holds details about calls to the DeviceResetNvLinkUtilizationCounter method.
|
|
DeviceResetNvLinkUtilizationCounter []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N1 is the n1 argument value.
|
|
N1 int
|
|
// N2 is the n2 argument value.
|
|
N2 int
|
|
}
|
|
// DeviceSetAPIRestriction holds details about calls to the DeviceSetAPIRestriction method.
|
|
DeviceSetAPIRestriction []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// RestrictedAPI is the restrictedAPI argument value.
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
// EnableState is the enableState argument value.
|
|
EnableState nvml.EnableState
|
|
}
|
|
// DeviceSetAccountingMode holds details about calls to the DeviceSetAccountingMode method.
|
|
DeviceSetAccountingMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// EnableState is the enableState argument value.
|
|
EnableState nvml.EnableState
|
|
}
|
|
// DeviceSetApplicationsClocks holds details about calls to the DeviceSetApplicationsClocks method.
|
|
DeviceSetApplicationsClocks []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// V1 is the v1 argument value.
|
|
V1 uint32
|
|
// V2 is the v2 argument value.
|
|
V2 uint32
|
|
}
|
|
// DeviceSetAutoBoostedClocksEnabled holds details about calls to the DeviceSetAutoBoostedClocksEnabled method.
|
|
DeviceSetAutoBoostedClocksEnabled []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// EnableState is the enableState argument value.
|
|
EnableState nvml.EnableState
|
|
}
|
|
// DeviceSetComputeMode holds details about calls to the DeviceSetComputeMode method.
|
|
DeviceSetComputeMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// ComputeMode is the computeMode argument value.
|
|
ComputeMode nvml.ComputeMode
|
|
}
|
|
// DeviceSetCpuAffinity holds details about calls to the DeviceSetCpuAffinity method.
|
|
DeviceSetCpuAffinity []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// DeviceSetDefaultAutoBoostedClocksEnabled holds details about calls to the DeviceSetDefaultAutoBoostedClocksEnabled method.
|
|
DeviceSetDefaultAutoBoostedClocksEnabled []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// EnableState is the enableState argument value.
|
|
EnableState nvml.EnableState
|
|
// V is the v argument value.
|
|
V uint32
|
|
}
|
|
// DeviceSetDefaultFanSpeed_v2 holds details about calls to the DeviceSetDefaultFanSpeed_v2 method.
|
|
DeviceSetDefaultFanSpeed_v2 []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceSetDriverModel holds details about calls to the DeviceSetDriverModel method.
|
|
DeviceSetDriverModel []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// DriverModel is the driverModel argument value.
|
|
DriverModel nvml.DriverModel
|
|
// V is the v argument value.
|
|
V uint32
|
|
}
|
|
// DeviceSetEccMode holds details about calls to the DeviceSetEccMode method.
|
|
DeviceSetEccMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// EnableState is the enableState argument value.
|
|
EnableState nvml.EnableState
|
|
}
|
|
// DeviceSetFanControlPolicy holds details about calls to the DeviceSetFanControlPolicy method.
|
|
DeviceSetFanControlPolicy []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
// FanControlPolicy is the fanControlPolicy argument value.
|
|
FanControlPolicy nvml.FanControlPolicy
|
|
}
|
|
// DeviceSetFanSpeed_v2 holds details about calls to the DeviceSetFanSpeed_v2 method.
|
|
DeviceSetFanSpeed_v2 []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N1 is the n1 argument value.
|
|
N1 int
|
|
// N2 is the n2 argument value.
|
|
N2 int
|
|
}
|
|
// DeviceSetGpcClkVfOffset holds details about calls to the DeviceSetGpcClkVfOffset method.
|
|
DeviceSetGpcClkVfOffset []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceSetGpuLockedClocks holds details about calls to the DeviceSetGpuLockedClocks method.
|
|
DeviceSetGpuLockedClocks []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// V1 is the v1 argument value.
|
|
V1 uint32
|
|
// V2 is the v2 argument value.
|
|
V2 uint32
|
|
}
|
|
// DeviceSetGpuOperationMode holds details about calls to the DeviceSetGpuOperationMode method.
|
|
DeviceSetGpuOperationMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// GpuOperationMode is the gpuOperationMode argument value.
|
|
GpuOperationMode nvml.GpuOperationMode
|
|
}
|
|
// DeviceSetMemClkVfOffset holds details about calls to the DeviceSetMemClkVfOffset method.
|
|
DeviceSetMemClkVfOffset []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceSetMemoryLockedClocks holds details about calls to the DeviceSetMemoryLockedClocks method.
|
|
DeviceSetMemoryLockedClocks []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// V1 is the v1 argument value.
|
|
V1 uint32
|
|
// V2 is the v2 argument value.
|
|
V2 uint32
|
|
}
|
|
// DeviceSetMigMode holds details about calls to the DeviceSetMigMode method.
|
|
DeviceSetMigMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceSetNvLinkDeviceLowPowerThreshold holds details about calls to the DeviceSetNvLinkDeviceLowPowerThreshold method.
|
|
DeviceSetNvLinkDeviceLowPowerThreshold []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// NvLinkPowerThres is the nvLinkPowerThres argument value.
|
|
NvLinkPowerThres *nvml.NvLinkPowerThres
|
|
}
|
|
// DeviceSetNvLinkUtilizationControl holds details about calls to the DeviceSetNvLinkUtilizationControl method.
|
|
DeviceSetNvLinkUtilizationControl []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N1 is the n1 argument value.
|
|
N1 int
|
|
// N2 is the n2 argument value.
|
|
N2 int
|
|
// NvLinkUtilizationControl is the nvLinkUtilizationControl argument value.
|
|
NvLinkUtilizationControl *nvml.NvLinkUtilizationControl
|
|
// B is the b argument value.
|
|
B bool
|
|
}
|
|
// DeviceSetPersistenceMode holds details about calls to the DeviceSetPersistenceMode method.
|
|
DeviceSetPersistenceMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// EnableState is the enableState argument value.
|
|
EnableState nvml.EnableState
|
|
}
|
|
// DeviceSetPowerManagementLimit holds details about calls to the DeviceSetPowerManagementLimit method.
|
|
DeviceSetPowerManagementLimit []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// V is the v argument value.
|
|
V uint32
|
|
}
|
|
// DeviceSetTemperatureThreshold holds details about calls to the DeviceSetTemperatureThreshold method.
|
|
DeviceSetTemperatureThreshold []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// TemperatureThresholds is the temperatureThresholds argument value.
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// DeviceSetVgpuSchedulerState holds details about calls to the DeviceSetVgpuSchedulerState method.
|
|
DeviceSetVgpuSchedulerState []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// VgpuSchedulerSetState is the vgpuSchedulerSetState argument value.
|
|
VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
|
|
}
|
|
// DeviceSetVirtualizationMode holds details about calls to the DeviceSetVirtualizationMode method.
|
|
DeviceSetVirtualizationMode []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// GpuVirtualizationMode is the gpuVirtualizationMode argument value.
|
|
GpuVirtualizationMode nvml.GpuVirtualizationMode
|
|
}
|
|
// DeviceValidateInforom holds details about calls to the DeviceValidateInforom method.
|
|
DeviceValidateInforom []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// ErrorString holds details about calls to the ErrorString method.
|
|
ErrorString []struct {
|
|
// ReturnMoqParam is the returnMoqParam argument value.
|
|
ReturnMoqParam nvml.Return
|
|
}
|
|
// EventSetCreate holds details about calls to the EventSetCreate method.
|
|
EventSetCreate []struct {
|
|
}
|
|
// EventSetFree holds details about calls to the EventSetFree method.
|
|
EventSetFree []struct {
|
|
// EventSet is the eventSet argument value.
|
|
EventSet nvml.EventSet
|
|
}
|
|
// EventSetWait holds details about calls to the EventSetWait method.
|
|
EventSetWait []struct {
|
|
// EventSet is the eventSet argument value.
|
|
EventSet nvml.EventSet
|
|
// V is the v argument value.
|
|
V uint32
|
|
}
|
|
// Extensions holds details about calls to the Extensions method.
|
|
Extensions []struct {
|
|
}
|
|
// GetExcludedDeviceCount holds details about calls to the GetExcludedDeviceCount method.
|
|
GetExcludedDeviceCount []struct {
|
|
}
|
|
// GetExcludedDeviceInfoByIndex holds details about calls to the GetExcludedDeviceInfoByIndex method.
|
|
GetExcludedDeviceInfoByIndex []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GetVgpuCompatibility holds details about calls to the GetVgpuCompatibility method.
|
|
GetVgpuCompatibility []struct {
|
|
// VgpuMetadata is the vgpuMetadata argument value.
|
|
VgpuMetadata *nvml.VgpuMetadata
|
|
// VgpuPgpuMetadata is the vgpuPgpuMetadata argument value.
|
|
VgpuPgpuMetadata *nvml.VgpuPgpuMetadata
|
|
}
|
|
// GetVgpuDriverCapabilities holds details about calls to the GetVgpuDriverCapabilities method.
|
|
GetVgpuDriverCapabilities []struct {
|
|
// VgpuDriverCapability is the vgpuDriverCapability argument value.
|
|
VgpuDriverCapability nvml.VgpuDriverCapability
|
|
}
|
|
// GetVgpuVersion holds details about calls to the GetVgpuVersion method.
|
|
GetVgpuVersion []struct {
|
|
}
|
|
// GpmMetricsGet holds details about calls to the GpmMetricsGet method.
|
|
GpmMetricsGet []struct {
|
|
// GpmMetricsGetType is the gpmMetricsGetType argument value.
|
|
GpmMetricsGetType *nvml.GpmMetricsGetType
|
|
}
|
|
// GpmMetricsGetV holds details about calls to the GpmMetricsGetV method.
|
|
GpmMetricsGetV []struct {
|
|
// GpmMetricsGetType is the gpmMetricsGetType argument value.
|
|
GpmMetricsGetType *nvml.GpmMetricsGetType
|
|
}
|
|
// GpmMigSampleGet holds details about calls to the GpmMigSampleGet method.
|
|
GpmMigSampleGet []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// N is the n argument value.
|
|
N int
|
|
// GpmSample is the gpmSample argument value.
|
|
GpmSample nvml.GpmSample
|
|
}
|
|
// GpmQueryDeviceSupport holds details about calls to the GpmQueryDeviceSupport method.
|
|
GpmQueryDeviceSupport []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// GpmQueryDeviceSupportV holds details about calls to the GpmQueryDeviceSupportV method.
|
|
GpmQueryDeviceSupportV []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// GpmSampleAlloc holds details about calls to the GpmSampleAlloc method.
|
|
GpmSampleAlloc []struct {
|
|
}
|
|
// GpmSampleFree holds details about calls to the GpmSampleFree method.
|
|
GpmSampleFree []struct {
|
|
// GpmSample is the gpmSample argument value.
|
|
GpmSample nvml.GpmSample
|
|
}
|
|
// GpmSampleGet holds details about calls to the GpmSampleGet method.
|
|
GpmSampleGet []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// GpmSample is the gpmSample argument value.
|
|
GpmSample nvml.GpmSample
|
|
}
|
|
// GpuInstanceCreateComputeInstance holds details about calls to the GpuInstanceCreateComputeInstance method.
|
|
GpuInstanceCreateComputeInstance []struct {
|
|
// GpuInstance is the gpuInstance argument value.
|
|
GpuInstance nvml.GpuInstance
|
|
// ComputeInstanceProfileInfo is the computeInstanceProfileInfo argument value.
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
}
|
|
// GpuInstanceCreateComputeInstanceWithPlacement holds details about calls to the GpuInstanceCreateComputeInstanceWithPlacement method.
|
|
GpuInstanceCreateComputeInstanceWithPlacement []struct {
|
|
// GpuInstance is the gpuInstance argument value.
|
|
GpuInstance nvml.GpuInstance
|
|
// ComputeInstanceProfileInfo is the computeInstanceProfileInfo argument value.
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
// ComputeInstancePlacement is the computeInstancePlacement argument value.
|
|
ComputeInstancePlacement *nvml.ComputeInstancePlacement
|
|
}
|
|
// GpuInstanceDestroy holds details about calls to the GpuInstanceDestroy method.
|
|
GpuInstanceDestroy []struct {
|
|
// GpuInstance is the gpuInstance argument value.
|
|
GpuInstance nvml.GpuInstance
|
|
}
|
|
// GpuInstanceGetComputeInstanceById holds details about calls to the GpuInstanceGetComputeInstanceById method.
|
|
GpuInstanceGetComputeInstanceById []struct {
|
|
// GpuInstance is the gpuInstance argument value.
|
|
GpuInstance nvml.GpuInstance
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GpuInstanceGetComputeInstancePossiblePlacements holds details about calls to the GpuInstanceGetComputeInstancePossiblePlacements method.
|
|
GpuInstanceGetComputeInstancePossiblePlacements []struct {
|
|
// GpuInstance is the gpuInstance argument value.
|
|
GpuInstance nvml.GpuInstance
|
|
// ComputeInstanceProfileInfo is the computeInstanceProfileInfo argument value.
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
}
|
|
// GpuInstanceGetComputeInstanceProfileInfo holds details about calls to the GpuInstanceGetComputeInstanceProfileInfo method.
|
|
GpuInstanceGetComputeInstanceProfileInfo []struct {
|
|
// GpuInstance is the gpuInstance argument value.
|
|
GpuInstance nvml.GpuInstance
|
|
// N1 is the n1 argument value.
|
|
N1 int
|
|
// N2 is the n2 argument value.
|
|
N2 int
|
|
}
|
|
// GpuInstanceGetComputeInstanceProfileInfoV holds details about calls to the GpuInstanceGetComputeInstanceProfileInfoV method.
|
|
GpuInstanceGetComputeInstanceProfileInfoV []struct {
|
|
// GpuInstance is the gpuInstance argument value.
|
|
GpuInstance nvml.GpuInstance
|
|
// N1 is the n1 argument value.
|
|
N1 int
|
|
// N2 is the n2 argument value.
|
|
N2 int
|
|
}
|
|
// GpuInstanceGetComputeInstanceRemainingCapacity holds details about calls to the GpuInstanceGetComputeInstanceRemainingCapacity method.
|
|
GpuInstanceGetComputeInstanceRemainingCapacity []struct {
|
|
// GpuInstance is the gpuInstance argument value.
|
|
GpuInstance nvml.GpuInstance
|
|
// ComputeInstanceProfileInfo is the computeInstanceProfileInfo argument value.
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
}
|
|
// GpuInstanceGetComputeInstances holds details about calls to the GpuInstanceGetComputeInstances method.
|
|
GpuInstanceGetComputeInstances []struct {
|
|
// GpuInstance is the gpuInstance argument value.
|
|
GpuInstance nvml.GpuInstance
|
|
// ComputeInstanceProfileInfo is the computeInstanceProfileInfo argument value.
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
}
|
|
// GpuInstanceGetInfo holds details about calls to the GpuInstanceGetInfo method.
|
|
GpuInstanceGetInfo []struct {
|
|
// GpuInstance is the gpuInstance argument value.
|
|
GpuInstance nvml.GpuInstance
|
|
}
|
|
// Init holds details about calls to the Init method.
|
|
Init []struct {
|
|
}
|
|
// InitWithFlags holds details about calls to the InitWithFlags method.
|
|
InitWithFlags []struct {
|
|
// V is the v argument value.
|
|
V uint32
|
|
}
|
|
// SetVgpuVersion holds details about calls to the SetVgpuVersion method.
|
|
SetVgpuVersion []struct {
|
|
// VgpuVersion is the vgpuVersion argument value.
|
|
VgpuVersion *nvml.VgpuVersion
|
|
}
|
|
// Shutdown holds details about calls to the Shutdown method.
|
|
Shutdown []struct {
|
|
}
|
|
// SystemGetCudaDriverVersion holds details about calls to the SystemGetCudaDriverVersion method.
|
|
SystemGetCudaDriverVersion []struct {
|
|
}
|
|
// SystemGetCudaDriverVersion_v2 holds details about calls to the SystemGetCudaDriverVersion_v2 method.
|
|
SystemGetCudaDriverVersion_v2 []struct {
|
|
}
|
|
// SystemGetDriverVersion holds details about calls to the SystemGetDriverVersion method.
|
|
SystemGetDriverVersion []struct {
|
|
}
|
|
// SystemGetHicVersion holds details about calls to the SystemGetHicVersion method.
|
|
SystemGetHicVersion []struct {
|
|
}
|
|
// SystemGetNVMLVersion holds details about calls to the SystemGetNVMLVersion method.
|
|
SystemGetNVMLVersion []struct {
|
|
}
|
|
// SystemGetProcessName holds details about calls to the SystemGetProcessName method.
|
|
SystemGetProcessName []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// SystemGetTopologyGpuSet holds details about calls to the SystemGetTopologyGpuSet method.
|
|
SystemGetTopologyGpuSet []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// UnitGetCount holds details about calls to the UnitGetCount method.
|
|
UnitGetCount []struct {
|
|
}
|
|
// UnitGetDevices holds details about calls to the UnitGetDevices method.
|
|
UnitGetDevices []struct {
|
|
// Unit is the unit argument value.
|
|
Unit nvml.Unit
|
|
}
|
|
// UnitGetFanSpeedInfo holds details about calls to the UnitGetFanSpeedInfo method.
|
|
UnitGetFanSpeedInfo []struct {
|
|
// Unit is the unit argument value.
|
|
Unit nvml.Unit
|
|
}
|
|
// UnitGetHandleByIndex holds details about calls to the UnitGetHandleByIndex method.
|
|
UnitGetHandleByIndex []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// UnitGetLedState holds details about calls to the UnitGetLedState method.
|
|
UnitGetLedState []struct {
|
|
// Unit is the unit argument value.
|
|
Unit nvml.Unit
|
|
}
|
|
// UnitGetPsuInfo holds details about calls to the UnitGetPsuInfo method.
|
|
UnitGetPsuInfo []struct {
|
|
// Unit is the unit argument value.
|
|
Unit nvml.Unit
|
|
}
|
|
// UnitGetTemperature holds details about calls to the UnitGetTemperature method.
|
|
UnitGetTemperature []struct {
|
|
// Unit is the unit argument value.
|
|
Unit nvml.Unit
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// UnitGetUnitInfo holds details about calls to the UnitGetUnitInfo method.
|
|
UnitGetUnitInfo []struct {
|
|
// Unit is the unit argument value.
|
|
Unit nvml.Unit
|
|
}
|
|
// UnitSetLedState holds details about calls to the UnitSetLedState method.
|
|
UnitSetLedState []struct {
|
|
// Unit is the unit argument value.
|
|
Unit nvml.Unit
|
|
// LedColor is the ledColor argument value.
|
|
LedColor nvml.LedColor
|
|
}
|
|
// VgpuInstanceClearAccountingPids holds details about calls to the VgpuInstanceClearAccountingPids method.
|
|
VgpuInstanceClearAccountingPids []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetAccountingMode holds details about calls to the VgpuInstanceGetAccountingMode method.
|
|
VgpuInstanceGetAccountingMode []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetAccountingPids holds details about calls to the VgpuInstanceGetAccountingPids method.
|
|
VgpuInstanceGetAccountingPids []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetAccountingStats holds details about calls to the VgpuInstanceGetAccountingStats method.
|
|
VgpuInstanceGetAccountingStats []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// VgpuInstanceGetEccMode holds details about calls to the VgpuInstanceGetEccMode method.
|
|
VgpuInstanceGetEccMode []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetEncoderCapacity holds details about calls to the VgpuInstanceGetEncoderCapacity method.
|
|
VgpuInstanceGetEncoderCapacity []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetEncoderSessions holds details about calls to the VgpuInstanceGetEncoderSessions method.
|
|
VgpuInstanceGetEncoderSessions []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetEncoderStats holds details about calls to the VgpuInstanceGetEncoderStats method.
|
|
VgpuInstanceGetEncoderStats []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetFBCSessions holds details about calls to the VgpuInstanceGetFBCSessions method.
|
|
VgpuInstanceGetFBCSessions []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetFBCStats holds details about calls to the VgpuInstanceGetFBCStats method.
|
|
VgpuInstanceGetFBCStats []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetFbUsage holds details about calls to the VgpuInstanceGetFbUsage method.
|
|
VgpuInstanceGetFbUsage []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetFrameRateLimit holds details about calls to the VgpuInstanceGetFrameRateLimit method.
|
|
VgpuInstanceGetFrameRateLimit []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetGpuInstanceId holds details about calls to the VgpuInstanceGetGpuInstanceId method.
|
|
VgpuInstanceGetGpuInstanceId []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetGpuPciId holds details about calls to the VgpuInstanceGetGpuPciId method.
|
|
VgpuInstanceGetGpuPciId []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetLicenseInfo holds details about calls to the VgpuInstanceGetLicenseInfo method.
|
|
VgpuInstanceGetLicenseInfo []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetLicenseStatus holds details about calls to the VgpuInstanceGetLicenseStatus method.
|
|
VgpuInstanceGetLicenseStatus []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetMdevUUID holds details about calls to the VgpuInstanceGetMdevUUID method.
|
|
VgpuInstanceGetMdevUUID []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetMetadata holds details about calls to the VgpuInstanceGetMetadata method.
|
|
VgpuInstanceGetMetadata []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetType holds details about calls to the VgpuInstanceGetType method.
|
|
VgpuInstanceGetType []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetUUID holds details about calls to the VgpuInstanceGetUUID method.
|
|
VgpuInstanceGetUUID []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetVmDriverVersion holds details about calls to the VgpuInstanceGetVmDriverVersion method.
|
|
VgpuInstanceGetVmDriverVersion []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceGetVmID holds details about calls to the VgpuInstanceGetVmID method.
|
|
VgpuInstanceGetVmID []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
// VgpuInstanceSetEncoderCapacity holds details about calls to the VgpuInstanceSetEncoderCapacity method.
|
|
VgpuInstanceSetEncoderCapacity []struct {
|
|
// VgpuInstance is the vgpuInstance argument value.
|
|
VgpuInstance nvml.VgpuInstance
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// VgpuTypeGetCapabilities holds details about calls to the VgpuTypeGetCapabilities method.
|
|
VgpuTypeGetCapabilities []struct {
|
|
// VgpuTypeId is the vgpuTypeId argument value.
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
// VgpuCapability is the vgpuCapability argument value.
|
|
VgpuCapability nvml.VgpuCapability
|
|
}
|
|
// VgpuTypeGetClass holds details about calls to the VgpuTypeGetClass method.
|
|
VgpuTypeGetClass []struct {
|
|
// VgpuTypeId is the vgpuTypeId argument value.
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
// VgpuTypeGetDeviceID holds details about calls to the VgpuTypeGetDeviceID method.
|
|
VgpuTypeGetDeviceID []struct {
|
|
// VgpuTypeId is the vgpuTypeId argument value.
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
// VgpuTypeGetFrameRateLimit holds details about calls to the VgpuTypeGetFrameRateLimit method.
|
|
VgpuTypeGetFrameRateLimit []struct {
|
|
// VgpuTypeId is the vgpuTypeId argument value.
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
// VgpuTypeGetFramebufferSize holds details about calls to the VgpuTypeGetFramebufferSize method.
|
|
VgpuTypeGetFramebufferSize []struct {
|
|
// VgpuTypeId is the vgpuTypeId argument value.
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
// VgpuTypeGetGpuInstanceProfileId holds details about calls to the VgpuTypeGetGpuInstanceProfileId method.
|
|
VgpuTypeGetGpuInstanceProfileId []struct {
|
|
// VgpuTypeId is the vgpuTypeId argument value.
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
// VgpuTypeGetLicense holds details about calls to the VgpuTypeGetLicense method.
|
|
VgpuTypeGetLicense []struct {
|
|
// VgpuTypeId is the vgpuTypeId argument value.
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
// VgpuTypeGetMaxInstances holds details about calls to the VgpuTypeGetMaxInstances method.
|
|
VgpuTypeGetMaxInstances []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// VgpuTypeId is the vgpuTypeId argument value.
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
// VgpuTypeGetMaxInstancesPerVm holds details about calls to the VgpuTypeGetMaxInstancesPerVm method.
|
|
VgpuTypeGetMaxInstancesPerVm []struct {
|
|
// VgpuTypeId is the vgpuTypeId argument value.
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
// VgpuTypeGetName holds details about calls to the VgpuTypeGetName method.
|
|
VgpuTypeGetName []struct {
|
|
// VgpuTypeId is the vgpuTypeId argument value.
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
// VgpuTypeGetNumDisplayHeads holds details about calls to the VgpuTypeGetNumDisplayHeads method.
|
|
VgpuTypeGetNumDisplayHeads []struct {
|
|
// VgpuTypeId is the vgpuTypeId argument value.
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
// VgpuTypeGetResolution holds details about calls to the VgpuTypeGetResolution method.
|
|
VgpuTypeGetResolution []struct {
|
|
// VgpuTypeId is the vgpuTypeId argument value.
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
}
|
|
lockComputeInstanceDestroy sync.RWMutex
|
|
lockComputeInstanceGetInfo sync.RWMutex
|
|
lockDeviceCcuGetStreamState sync.RWMutex
|
|
lockDeviceCcuSetStreamState sync.RWMutex
|
|
lockDeviceClearAccountingPids sync.RWMutex
|
|
lockDeviceClearCpuAffinity sync.RWMutex
|
|
lockDeviceClearEccErrorCounts sync.RWMutex
|
|
lockDeviceClearFieldValues sync.RWMutex
|
|
lockDeviceCreateGpuInstance sync.RWMutex
|
|
lockDeviceCreateGpuInstanceWithPlacement sync.RWMutex
|
|
lockDeviceDiscoverGpus sync.RWMutex
|
|
lockDeviceFreezeNvLinkUtilizationCounter sync.RWMutex
|
|
lockDeviceGetAPIRestriction sync.RWMutex
|
|
lockDeviceGetAccountingBufferSize sync.RWMutex
|
|
lockDeviceGetAccountingMode sync.RWMutex
|
|
lockDeviceGetAccountingPids sync.RWMutex
|
|
lockDeviceGetAccountingStats sync.RWMutex
|
|
lockDeviceGetActiveVgpus sync.RWMutex
|
|
lockDeviceGetAdaptiveClockInfoStatus sync.RWMutex
|
|
lockDeviceGetApplicationsClock sync.RWMutex
|
|
lockDeviceGetArchitecture sync.RWMutex
|
|
lockDeviceGetAttributes sync.RWMutex
|
|
lockDeviceGetAutoBoostedClocksEnabled sync.RWMutex
|
|
lockDeviceGetBAR1MemoryInfo sync.RWMutex
|
|
lockDeviceGetBoardId sync.RWMutex
|
|
lockDeviceGetBoardPartNumber sync.RWMutex
|
|
lockDeviceGetBrand sync.RWMutex
|
|
lockDeviceGetBridgeChipInfo sync.RWMutex
|
|
lockDeviceGetBusType sync.RWMutex
|
|
lockDeviceGetClkMonStatus sync.RWMutex
|
|
lockDeviceGetClock sync.RWMutex
|
|
lockDeviceGetClockInfo sync.RWMutex
|
|
lockDeviceGetComputeInstanceId sync.RWMutex
|
|
lockDeviceGetComputeMode sync.RWMutex
|
|
lockDeviceGetComputeRunningProcesses sync.RWMutex
|
|
lockDeviceGetCount sync.RWMutex
|
|
lockDeviceGetCpuAffinity sync.RWMutex
|
|
lockDeviceGetCpuAffinityWithinScope sync.RWMutex
|
|
lockDeviceGetCreatableVgpus sync.RWMutex
|
|
lockDeviceGetCudaComputeCapability sync.RWMutex
|
|
lockDeviceGetCurrPcieLinkGeneration sync.RWMutex
|
|
lockDeviceGetCurrPcieLinkWidth sync.RWMutex
|
|
lockDeviceGetCurrentClocksThrottleReasons sync.RWMutex
|
|
lockDeviceGetDecoderUtilization sync.RWMutex
|
|
lockDeviceGetDefaultApplicationsClock sync.RWMutex
|
|
lockDeviceGetDefaultEccMode sync.RWMutex
|
|
lockDeviceGetDetailedEccErrors sync.RWMutex
|
|
lockDeviceGetDeviceHandleFromMigDeviceHandle sync.RWMutex
|
|
lockDeviceGetDisplayActive sync.RWMutex
|
|
lockDeviceGetDisplayMode sync.RWMutex
|
|
lockDeviceGetDriverModel sync.RWMutex
|
|
lockDeviceGetDynamicPstatesInfo sync.RWMutex
|
|
lockDeviceGetEccMode sync.RWMutex
|
|
lockDeviceGetEncoderCapacity sync.RWMutex
|
|
lockDeviceGetEncoderSessions sync.RWMutex
|
|
lockDeviceGetEncoderStats sync.RWMutex
|
|
lockDeviceGetEncoderUtilization sync.RWMutex
|
|
lockDeviceGetEnforcedPowerLimit sync.RWMutex
|
|
lockDeviceGetFBCSessions sync.RWMutex
|
|
lockDeviceGetFBCStats sync.RWMutex
|
|
lockDeviceGetFanControlPolicy_v2 sync.RWMutex
|
|
lockDeviceGetFanSpeed sync.RWMutex
|
|
lockDeviceGetFanSpeed_v2 sync.RWMutex
|
|
lockDeviceGetFieldValues sync.RWMutex
|
|
lockDeviceGetGpcClkMinMaxVfOffset sync.RWMutex
|
|
lockDeviceGetGpcClkVfOffset sync.RWMutex
|
|
lockDeviceGetGpuFabricInfo sync.RWMutex
|
|
lockDeviceGetGpuInstanceById sync.RWMutex
|
|
lockDeviceGetGpuInstanceId sync.RWMutex
|
|
lockDeviceGetGpuInstancePossiblePlacements sync.RWMutex
|
|
lockDeviceGetGpuInstanceProfileInfo sync.RWMutex
|
|
lockDeviceGetGpuInstanceProfileInfoV sync.RWMutex
|
|
lockDeviceGetGpuInstanceRemainingCapacity sync.RWMutex
|
|
lockDeviceGetGpuInstances sync.RWMutex
|
|
lockDeviceGetGpuMaxPcieLinkGeneration sync.RWMutex
|
|
lockDeviceGetGpuOperationMode sync.RWMutex
|
|
lockDeviceGetGraphicsRunningProcesses sync.RWMutex
|
|
lockDeviceGetGridLicensableFeatures sync.RWMutex
|
|
lockDeviceGetGspFirmwareMode sync.RWMutex
|
|
lockDeviceGetGspFirmwareVersion sync.RWMutex
|
|
lockDeviceGetHandleByIndex sync.RWMutex
|
|
lockDeviceGetHandleByPciBusId sync.RWMutex
|
|
lockDeviceGetHandleBySerial sync.RWMutex
|
|
lockDeviceGetHandleByUUID sync.RWMutex
|
|
lockDeviceGetHostVgpuMode sync.RWMutex
|
|
lockDeviceGetIndex sync.RWMutex
|
|
lockDeviceGetInforomConfigurationChecksum sync.RWMutex
|
|
lockDeviceGetInforomImageVersion sync.RWMutex
|
|
lockDeviceGetInforomVersion sync.RWMutex
|
|
lockDeviceGetIrqNum sync.RWMutex
|
|
lockDeviceGetMPSComputeRunningProcesses sync.RWMutex
|
|
lockDeviceGetMaxClockInfo sync.RWMutex
|
|
lockDeviceGetMaxCustomerBoostClock sync.RWMutex
|
|
lockDeviceGetMaxMigDeviceCount sync.RWMutex
|
|
lockDeviceGetMaxPcieLinkGeneration sync.RWMutex
|
|
lockDeviceGetMaxPcieLinkWidth sync.RWMutex
|
|
lockDeviceGetMemClkMinMaxVfOffset sync.RWMutex
|
|
lockDeviceGetMemClkVfOffset sync.RWMutex
|
|
lockDeviceGetMemoryAffinity sync.RWMutex
|
|
lockDeviceGetMemoryBusWidth sync.RWMutex
|
|
lockDeviceGetMemoryErrorCounter sync.RWMutex
|
|
lockDeviceGetMemoryInfo sync.RWMutex
|
|
lockDeviceGetMemoryInfo_v2 sync.RWMutex
|
|
lockDeviceGetMigDeviceHandleByIndex sync.RWMutex
|
|
lockDeviceGetMigMode sync.RWMutex
|
|
lockDeviceGetMinMaxClockOfPState sync.RWMutex
|
|
lockDeviceGetMinMaxFanSpeed sync.RWMutex
|
|
lockDeviceGetMinorNumber sync.RWMutex
|
|
lockDeviceGetMultiGpuBoard sync.RWMutex
|
|
lockDeviceGetName sync.RWMutex
|
|
lockDeviceGetNumFans sync.RWMutex
|
|
lockDeviceGetNumGpuCores sync.RWMutex
|
|
lockDeviceGetNvLinkCapability sync.RWMutex
|
|
lockDeviceGetNvLinkErrorCounter sync.RWMutex
|
|
lockDeviceGetNvLinkRemoteDeviceType sync.RWMutex
|
|
lockDeviceGetNvLinkRemotePciInfo sync.RWMutex
|
|
lockDeviceGetNvLinkState sync.RWMutex
|
|
lockDeviceGetNvLinkUtilizationControl sync.RWMutex
|
|
lockDeviceGetNvLinkUtilizationCounter sync.RWMutex
|
|
lockDeviceGetNvLinkVersion sync.RWMutex
|
|
lockDeviceGetP2PStatus sync.RWMutex
|
|
lockDeviceGetPciInfo sync.RWMutex
|
|
lockDeviceGetPcieLinkMaxSpeed sync.RWMutex
|
|
lockDeviceGetPcieReplayCounter sync.RWMutex
|
|
lockDeviceGetPcieSpeed sync.RWMutex
|
|
lockDeviceGetPcieThroughput sync.RWMutex
|
|
lockDeviceGetPerformanceState sync.RWMutex
|
|
lockDeviceGetPersistenceMode sync.RWMutex
|
|
lockDeviceGetPgpuMetadataString sync.RWMutex
|
|
lockDeviceGetPowerManagementDefaultLimit sync.RWMutex
|
|
lockDeviceGetPowerManagementLimit sync.RWMutex
|
|
lockDeviceGetPowerManagementLimitConstraints sync.RWMutex
|
|
lockDeviceGetPowerManagementMode sync.RWMutex
|
|
lockDeviceGetPowerSource sync.RWMutex
|
|
lockDeviceGetPowerState sync.RWMutex
|
|
lockDeviceGetPowerUsage sync.RWMutex
|
|
lockDeviceGetProcessUtilization sync.RWMutex
|
|
lockDeviceGetRemappedRows sync.RWMutex
|
|
lockDeviceGetRetiredPages sync.RWMutex
|
|
lockDeviceGetRetiredPagesPendingStatus sync.RWMutex
|
|
lockDeviceGetRetiredPages_v2 sync.RWMutex
|
|
lockDeviceGetRowRemapperHistogram sync.RWMutex
|
|
lockDeviceGetSamples sync.RWMutex
|
|
lockDeviceGetSerial sync.RWMutex
|
|
lockDeviceGetSupportedClocksThrottleReasons sync.RWMutex
|
|
lockDeviceGetSupportedEventTypes sync.RWMutex
|
|
lockDeviceGetSupportedGraphicsClocks sync.RWMutex
|
|
lockDeviceGetSupportedMemoryClocks sync.RWMutex
|
|
lockDeviceGetSupportedPerformanceStates sync.RWMutex
|
|
lockDeviceGetSupportedVgpus sync.RWMutex
|
|
lockDeviceGetTargetFanSpeed sync.RWMutex
|
|
lockDeviceGetTemperature sync.RWMutex
|
|
lockDeviceGetTemperatureThreshold sync.RWMutex
|
|
lockDeviceGetThermalSettings sync.RWMutex
|
|
lockDeviceGetTopologyCommonAncestor sync.RWMutex
|
|
lockDeviceGetTopologyNearestGpus sync.RWMutex
|
|
lockDeviceGetTotalEccErrors sync.RWMutex
|
|
lockDeviceGetTotalEnergyConsumption sync.RWMutex
|
|
lockDeviceGetUUID sync.RWMutex
|
|
lockDeviceGetUtilizationRates sync.RWMutex
|
|
lockDeviceGetVbiosVersion sync.RWMutex
|
|
lockDeviceGetVgpuCapabilities sync.RWMutex
|
|
lockDeviceGetVgpuMetadata sync.RWMutex
|
|
lockDeviceGetVgpuProcessUtilization sync.RWMutex
|
|
lockDeviceGetVgpuSchedulerCapabilities sync.RWMutex
|
|
lockDeviceGetVgpuSchedulerLog sync.RWMutex
|
|
lockDeviceGetVgpuSchedulerState sync.RWMutex
|
|
lockDeviceGetVgpuUtilization sync.RWMutex
|
|
lockDeviceGetViolationStatus sync.RWMutex
|
|
lockDeviceGetVirtualizationMode sync.RWMutex
|
|
lockDeviceIsMigDeviceHandle sync.RWMutex
|
|
lockDeviceModifyDrainState sync.RWMutex
|
|
lockDeviceOnSameBoard sync.RWMutex
|
|
lockDeviceQueryDrainState sync.RWMutex
|
|
lockDeviceRegisterEvents sync.RWMutex
|
|
lockDeviceRemoveGpu sync.RWMutex
|
|
lockDeviceRemoveGpu_v2 sync.RWMutex
|
|
lockDeviceResetApplicationsClocks sync.RWMutex
|
|
lockDeviceResetGpuLockedClocks sync.RWMutex
|
|
lockDeviceResetMemoryLockedClocks sync.RWMutex
|
|
lockDeviceResetNvLinkErrorCounters sync.RWMutex
|
|
lockDeviceResetNvLinkUtilizationCounter sync.RWMutex
|
|
lockDeviceSetAPIRestriction sync.RWMutex
|
|
lockDeviceSetAccountingMode sync.RWMutex
|
|
lockDeviceSetApplicationsClocks sync.RWMutex
|
|
lockDeviceSetAutoBoostedClocksEnabled sync.RWMutex
|
|
lockDeviceSetComputeMode sync.RWMutex
|
|
lockDeviceSetCpuAffinity sync.RWMutex
|
|
lockDeviceSetDefaultAutoBoostedClocksEnabled sync.RWMutex
|
|
lockDeviceSetDefaultFanSpeed_v2 sync.RWMutex
|
|
lockDeviceSetDriverModel sync.RWMutex
|
|
lockDeviceSetEccMode sync.RWMutex
|
|
lockDeviceSetFanControlPolicy sync.RWMutex
|
|
lockDeviceSetFanSpeed_v2 sync.RWMutex
|
|
lockDeviceSetGpcClkVfOffset sync.RWMutex
|
|
lockDeviceSetGpuLockedClocks sync.RWMutex
|
|
lockDeviceSetGpuOperationMode sync.RWMutex
|
|
lockDeviceSetMemClkVfOffset sync.RWMutex
|
|
lockDeviceSetMemoryLockedClocks sync.RWMutex
|
|
lockDeviceSetMigMode sync.RWMutex
|
|
lockDeviceSetNvLinkDeviceLowPowerThreshold sync.RWMutex
|
|
lockDeviceSetNvLinkUtilizationControl sync.RWMutex
|
|
lockDeviceSetPersistenceMode sync.RWMutex
|
|
lockDeviceSetPowerManagementLimit sync.RWMutex
|
|
lockDeviceSetTemperatureThreshold sync.RWMutex
|
|
lockDeviceSetVgpuSchedulerState sync.RWMutex
|
|
lockDeviceSetVirtualizationMode sync.RWMutex
|
|
lockDeviceValidateInforom sync.RWMutex
|
|
lockErrorString sync.RWMutex
|
|
lockEventSetCreate sync.RWMutex
|
|
lockEventSetFree sync.RWMutex
|
|
lockEventSetWait sync.RWMutex
|
|
lockExtensions sync.RWMutex
|
|
lockGetExcludedDeviceCount sync.RWMutex
|
|
lockGetExcludedDeviceInfoByIndex sync.RWMutex
|
|
lockGetVgpuCompatibility sync.RWMutex
|
|
lockGetVgpuDriverCapabilities sync.RWMutex
|
|
lockGetVgpuVersion sync.RWMutex
|
|
lockGpmMetricsGet sync.RWMutex
|
|
lockGpmMetricsGetV sync.RWMutex
|
|
lockGpmMigSampleGet sync.RWMutex
|
|
lockGpmQueryDeviceSupport sync.RWMutex
|
|
lockGpmQueryDeviceSupportV sync.RWMutex
|
|
lockGpmSampleAlloc sync.RWMutex
|
|
lockGpmSampleFree sync.RWMutex
|
|
lockGpmSampleGet sync.RWMutex
|
|
lockGpuInstanceCreateComputeInstance sync.RWMutex
|
|
lockGpuInstanceCreateComputeInstanceWithPlacement sync.RWMutex
|
|
lockGpuInstanceDestroy sync.RWMutex
|
|
lockGpuInstanceGetComputeInstanceById sync.RWMutex
|
|
lockGpuInstanceGetComputeInstancePossiblePlacements sync.RWMutex
|
|
lockGpuInstanceGetComputeInstanceProfileInfo sync.RWMutex
|
|
lockGpuInstanceGetComputeInstanceProfileInfoV sync.RWMutex
|
|
lockGpuInstanceGetComputeInstanceRemainingCapacity sync.RWMutex
|
|
lockGpuInstanceGetComputeInstances sync.RWMutex
|
|
lockGpuInstanceGetInfo sync.RWMutex
|
|
lockInit sync.RWMutex
|
|
lockInitWithFlags sync.RWMutex
|
|
lockSetVgpuVersion sync.RWMutex
|
|
lockShutdown sync.RWMutex
|
|
lockSystemGetCudaDriverVersion sync.RWMutex
|
|
lockSystemGetCudaDriverVersion_v2 sync.RWMutex
|
|
lockSystemGetDriverVersion sync.RWMutex
|
|
lockSystemGetHicVersion sync.RWMutex
|
|
lockSystemGetNVMLVersion sync.RWMutex
|
|
lockSystemGetProcessName sync.RWMutex
|
|
lockSystemGetTopologyGpuSet sync.RWMutex
|
|
lockUnitGetCount sync.RWMutex
|
|
lockUnitGetDevices sync.RWMutex
|
|
lockUnitGetFanSpeedInfo sync.RWMutex
|
|
lockUnitGetHandleByIndex sync.RWMutex
|
|
lockUnitGetLedState sync.RWMutex
|
|
lockUnitGetPsuInfo sync.RWMutex
|
|
lockUnitGetTemperature sync.RWMutex
|
|
lockUnitGetUnitInfo sync.RWMutex
|
|
lockUnitSetLedState sync.RWMutex
|
|
lockVgpuInstanceClearAccountingPids sync.RWMutex
|
|
lockVgpuInstanceGetAccountingMode sync.RWMutex
|
|
lockVgpuInstanceGetAccountingPids sync.RWMutex
|
|
lockVgpuInstanceGetAccountingStats sync.RWMutex
|
|
lockVgpuInstanceGetEccMode sync.RWMutex
|
|
lockVgpuInstanceGetEncoderCapacity sync.RWMutex
|
|
lockVgpuInstanceGetEncoderSessions sync.RWMutex
|
|
lockVgpuInstanceGetEncoderStats sync.RWMutex
|
|
lockVgpuInstanceGetFBCSessions sync.RWMutex
|
|
lockVgpuInstanceGetFBCStats sync.RWMutex
|
|
lockVgpuInstanceGetFbUsage sync.RWMutex
|
|
lockVgpuInstanceGetFrameRateLimit sync.RWMutex
|
|
lockVgpuInstanceGetGpuInstanceId sync.RWMutex
|
|
lockVgpuInstanceGetGpuPciId sync.RWMutex
|
|
lockVgpuInstanceGetLicenseInfo sync.RWMutex
|
|
lockVgpuInstanceGetLicenseStatus sync.RWMutex
|
|
lockVgpuInstanceGetMdevUUID sync.RWMutex
|
|
lockVgpuInstanceGetMetadata sync.RWMutex
|
|
lockVgpuInstanceGetType sync.RWMutex
|
|
lockVgpuInstanceGetUUID sync.RWMutex
|
|
lockVgpuInstanceGetVmDriverVersion sync.RWMutex
|
|
lockVgpuInstanceGetVmID sync.RWMutex
|
|
lockVgpuInstanceSetEncoderCapacity sync.RWMutex
|
|
lockVgpuTypeGetCapabilities sync.RWMutex
|
|
lockVgpuTypeGetClass sync.RWMutex
|
|
lockVgpuTypeGetDeviceID sync.RWMutex
|
|
lockVgpuTypeGetFrameRateLimit sync.RWMutex
|
|
lockVgpuTypeGetFramebufferSize sync.RWMutex
|
|
lockVgpuTypeGetGpuInstanceProfileId sync.RWMutex
|
|
lockVgpuTypeGetLicense sync.RWMutex
|
|
lockVgpuTypeGetMaxInstances sync.RWMutex
|
|
lockVgpuTypeGetMaxInstancesPerVm sync.RWMutex
|
|
lockVgpuTypeGetName sync.RWMutex
|
|
lockVgpuTypeGetNumDisplayHeads sync.RWMutex
|
|
lockVgpuTypeGetResolution sync.RWMutex
|
|
}
|
|
|
|
// ComputeInstanceDestroy calls ComputeInstanceDestroyFunc.
|
|
func (mock *Interface) ComputeInstanceDestroy(computeInstance nvml.ComputeInstance) nvml.Return {
|
|
if mock.ComputeInstanceDestroyFunc == nil {
|
|
panic("Interface.ComputeInstanceDestroyFunc: method is nil but Interface.ComputeInstanceDestroy was just called")
|
|
}
|
|
callInfo := struct {
|
|
ComputeInstance nvml.ComputeInstance
|
|
}{
|
|
ComputeInstance: computeInstance,
|
|
}
|
|
mock.lockComputeInstanceDestroy.Lock()
|
|
mock.calls.ComputeInstanceDestroy = append(mock.calls.ComputeInstanceDestroy, callInfo)
|
|
mock.lockComputeInstanceDestroy.Unlock()
|
|
return mock.ComputeInstanceDestroyFunc(computeInstance)
|
|
}
|
|
|
|
// ComputeInstanceDestroyCalls gets all the calls that were made to ComputeInstanceDestroy.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.ComputeInstanceDestroyCalls())
|
|
func (mock *Interface) ComputeInstanceDestroyCalls() []struct {
|
|
ComputeInstance nvml.ComputeInstance
|
|
} {
|
|
var calls []struct {
|
|
ComputeInstance nvml.ComputeInstance
|
|
}
|
|
mock.lockComputeInstanceDestroy.RLock()
|
|
calls = mock.calls.ComputeInstanceDestroy
|
|
mock.lockComputeInstanceDestroy.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// ComputeInstanceGetInfo calls ComputeInstanceGetInfoFunc.
|
|
func (mock *Interface) ComputeInstanceGetInfo(computeInstance nvml.ComputeInstance) (nvml.ComputeInstanceInfo, nvml.Return) {
|
|
if mock.ComputeInstanceGetInfoFunc == nil {
|
|
panic("Interface.ComputeInstanceGetInfoFunc: method is nil but Interface.ComputeInstanceGetInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
ComputeInstance nvml.ComputeInstance
|
|
}{
|
|
ComputeInstance: computeInstance,
|
|
}
|
|
mock.lockComputeInstanceGetInfo.Lock()
|
|
mock.calls.ComputeInstanceGetInfo = append(mock.calls.ComputeInstanceGetInfo, callInfo)
|
|
mock.lockComputeInstanceGetInfo.Unlock()
|
|
return mock.ComputeInstanceGetInfoFunc(computeInstance)
|
|
}
|
|
|
|
// ComputeInstanceGetInfoCalls gets all the calls that were made to ComputeInstanceGetInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.ComputeInstanceGetInfoCalls())
|
|
func (mock *Interface) ComputeInstanceGetInfoCalls() []struct {
|
|
ComputeInstance nvml.ComputeInstance
|
|
} {
|
|
var calls []struct {
|
|
ComputeInstance nvml.ComputeInstance
|
|
}
|
|
mock.lockComputeInstanceGetInfo.RLock()
|
|
calls = mock.calls.ComputeInstanceGetInfo
|
|
mock.lockComputeInstanceGetInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceCcuGetStreamState calls DeviceCcuGetStreamStateFunc.
|
|
func (mock *Interface) DeviceCcuGetStreamState(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceCcuGetStreamStateFunc == nil {
|
|
panic("Interface.DeviceCcuGetStreamStateFunc: method is nil but Interface.DeviceCcuGetStreamState was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceCcuGetStreamState.Lock()
|
|
mock.calls.DeviceCcuGetStreamState = append(mock.calls.DeviceCcuGetStreamState, callInfo)
|
|
mock.lockDeviceCcuGetStreamState.Unlock()
|
|
return mock.DeviceCcuGetStreamStateFunc(device)
|
|
}
|
|
|
|
// DeviceCcuGetStreamStateCalls gets all the calls that were made to DeviceCcuGetStreamState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceCcuGetStreamStateCalls())
|
|
func (mock *Interface) DeviceCcuGetStreamStateCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceCcuGetStreamState.RLock()
|
|
calls = mock.calls.DeviceCcuGetStreamState
|
|
mock.lockDeviceCcuGetStreamState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceCcuSetStreamState calls DeviceCcuSetStreamStateFunc.
|
|
func (mock *Interface) DeviceCcuSetStreamState(device nvml.Device, n int) nvml.Return {
|
|
if mock.DeviceCcuSetStreamStateFunc == nil {
|
|
panic("Interface.DeviceCcuSetStreamStateFunc: method is nil but Interface.DeviceCcuSetStreamState was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceCcuSetStreamState.Lock()
|
|
mock.calls.DeviceCcuSetStreamState = append(mock.calls.DeviceCcuSetStreamState, callInfo)
|
|
mock.lockDeviceCcuSetStreamState.Unlock()
|
|
return mock.DeviceCcuSetStreamStateFunc(device, n)
|
|
}
|
|
|
|
// DeviceCcuSetStreamStateCalls gets all the calls that were made to DeviceCcuSetStreamState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceCcuSetStreamStateCalls())
|
|
func (mock *Interface) DeviceCcuSetStreamStateCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceCcuSetStreamState.RLock()
|
|
calls = mock.calls.DeviceCcuSetStreamState
|
|
mock.lockDeviceCcuSetStreamState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceClearAccountingPids calls DeviceClearAccountingPidsFunc.
|
|
func (mock *Interface) DeviceClearAccountingPids(device nvml.Device) nvml.Return {
|
|
if mock.DeviceClearAccountingPidsFunc == nil {
|
|
panic("Interface.DeviceClearAccountingPidsFunc: method is nil but Interface.DeviceClearAccountingPids was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceClearAccountingPids.Lock()
|
|
mock.calls.DeviceClearAccountingPids = append(mock.calls.DeviceClearAccountingPids, callInfo)
|
|
mock.lockDeviceClearAccountingPids.Unlock()
|
|
return mock.DeviceClearAccountingPidsFunc(device)
|
|
}
|
|
|
|
// DeviceClearAccountingPidsCalls gets all the calls that were made to DeviceClearAccountingPids.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceClearAccountingPidsCalls())
|
|
func (mock *Interface) DeviceClearAccountingPidsCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceClearAccountingPids.RLock()
|
|
calls = mock.calls.DeviceClearAccountingPids
|
|
mock.lockDeviceClearAccountingPids.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceClearCpuAffinity calls DeviceClearCpuAffinityFunc.
|
|
func (mock *Interface) DeviceClearCpuAffinity(device nvml.Device) nvml.Return {
|
|
if mock.DeviceClearCpuAffinityFunc == nil {
|
|
panic("Interface.DeviceClearCpuAffinityFunc: method is nil but Interface.DeviceClearCpuAffinity was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceClearCpuAffinity.Lock()
|
|
mock.calls.DeviceClearCpuAffinity = append(mock.calls.DeviceClearCpuAffinity, callInfo)
|
|
mock.lockDeviceClearCpuAffinity.Unlock()
|
|
return mock.DeviceClearCpuAffinityFunc(device)
|
|
}
|
|
|
|
// DeviceClearCpuAffinityCalls gets all the calls that were made to DeviceClearCpuAffinity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceClearCpuAffinityCalls())
|
|
func (mock *Interface) DeviceClearCpuAffinityCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceClearCpuAffinity.RLock()
|
|
calls = mock.calls.DeviceClearCpuAffinity
|
|
mock.lockDeviceClearCpuAffinity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceClearEccErrorCounts calls DeviceClearEccErrorCountsFunc.
|
|
func (mock *Interface) DeviceClearEccErrorCounts(device nvml.Device, eccCounterType nvml.EccCounterType) nvml.Return {
|
|
if mock.DeviceClearEccErrorCountsFunc == nil {
|
|
panic("Interface.DeviceClearEccErrorCountsFunc: method is nil but Interface.DeviceClearEccErrorCounts was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
EccCounterType nvml.EccCounterType
|
|
}{
|
|
Device: device,
|
|
EccCounterType: eccCounterType,
|
|
}
|
|
mock.lockDeviceClearEccErrorCounts.Lock()
|
|
mock.calls.DeviceClearEccErrorCounts = append(mock.calls.DeviceClearEccErrorCounts, callInfo)
|
|
mock.lockDeviceClearEccErrorCounts.Unlock()
|
|
return mock.DeviceClearEccErrorCountsFunc(device, eccCounterType)
|
|
}
|
|
|
|
// DeviceClearEccErrorCountsCalls gets all the calls that were made to DeviceClearEccErrorCounts.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceClearEccErrorCountsCalls())
|
|
func (mock *Interface) DeviceClearEccErrorCountsCalls() []struct {
|
|
Device nvml.Device
|
|
EccCounterType nvml.EccCounterType
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
EccCounterType nvml.EccCounterType
|
|
}
|
|
mock.lockDeviceClearEccErrorCounts.RLock()
|
|
calls = mock.calls.DeviceClearEccErrorCounts
|
|
mock.lockDeviceClearEccErrorCounts.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceClearFieldValues calls DeviceClearFieldValuesFunc.
|
|
func (mock *Interface) DeviceClearFieldValues(device nvml.Device, fieldValues []nvml.FieldValue) nvml.Return {
|
|
if mock.DeviceClearFieldValuesFunc == nil {
|
|
panic("Interface.DeviceClearFieldValuesFunc: method is nil but Interface.DeviceClearFieldValues was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
FieldValues []nvml.FieldValue
|
|
}{
|
|
Device: device,
|
|
FieldValues: fieldValues,
|
|
}
|
|
mock.lockDeviceClearFieldValues.Lock()
|
|
mock.calls.DeviceClearFieldValues = append(mock.calls.DeviceClearFieldValues, callInfo)
|
|
mock.lockDeviceClearFieldValues.Unlock()
|
|
return mock.DeviceClearFieldValuesFunc(device, fieldValues)
|
|
}
|
|
|
|
// DeviceClearFieldValuesCalls gets all the calls that were made to DeviceClearFieldValues.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceClearFieldValuesCalls())
|
|
func (mock *Interface) DeviceClearFieldValuesCalls() []struct {
|
|
Device nvml.Device
|
|
FieldValues []nvml.FieldValue
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
FieldValues []nvml.FieldValue
|
|
}
|
|
mock.lockDeviceClearFieldValues.RLock()
|
|
calls = mock.calls.DeviceClearFieldValues
|
|
mock.lockDeviceClearFieldValues.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceCreateGpuInstance calls DeviceCreateGpuInstanceFunc.
|
|
func (mock *Interface) DeviceCreateGpuInstance(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (nvml.GpuInstance, nvml.Return) {
|
|
if mock.DeviceCreateGpuInstanceFunc == nil {
|
|
panic("Interface.DeviceCreateGpuInstanceFunc: method is nil but Interface.DeviceCreateGpuInstance was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}{
|
|
Device: device,
|
|
GpuInstanceProfileInfo: gpuInstanceProfileInfo,
|
|
}
|
|
mock.lockDeviceCreateGpuInstance.Lock()
|
|
mock.calls.DeviceCreateGpuInstance = append(mock.calls.DeviceCreateGpuInstance, callInfo)
|
|
mock.lockDeviceCreateGpuInstance.Unlock()
|
|
return mock.DeviceCreateGpuInstanceFunc(device, gpuInstanceProfileInfo)
|
|
}
|
|
|
|
// DeviceCreateGpuInstanceCalls gets all the calls that were made to DeviceCreateGpuInstance.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceCreateGpuInstanceCalls())
|
|
func (mock *Interface) DeviceCreateGpuInstanceCalls() []struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
mock.lockDeviceCreateGpuInstance.RLock()
|
|
calls = mock.calls.DeviceCreateGpuInstance
|
|
mock.lockDeviceCreateGpuInstance.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceCreateGpuInstanceWithPlacement calls DeviceCreateGpuInstanceWithPlacementFunc.
|
|
func (mock *Interface) DeviceCreateGpuInstanceWithPlacement(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo, gpuInstancePlacement *nvml.GpuInstancePlacement) (nvml.GpuInstance, nvml.Return) {
|
|
if mock.DeviceCreateGpuInstanceWithPlacementFunc == nil {
|
|
panic("Interface.DeviceCreateGpuInstanceWithPlacementFunc: method is nil but Interface.DeviceCreateGpuInstanceWithPlacement was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
GpuInstancePlacement *nvml.GpuInstancePlacement
|
|
}{
|
|
Device: device,
|
|
GpuInstanceProfileInfo: gpuInstanceProfileInfo,
|
|
GpuInstancePlacement: gpuInstancePlacement,
|
|
}
|
|
mock.lockDeviceCreateGpuInstanceWithPlacement.Lock()
|
|
mock.calls.DeviceCreateGpuInstanceWithPlacement = append(mock.calls.DeviceCreateGpuInstanceWithPlacement, callInfo)
|
|
mock.lockDeviceCreateGpuInstanceWithPlacement.Unlock()
|
|
return mock.DeviceCreateGpuInstanceWithPlacementFunc(device, gpuInstanceProfileInfo, gpuInstancePlacement)
|
|
}
|
|
|
|
// DeviceCreateGpuInstanceWithPlacementCalls gets all the calls that were made to DeviceCreateGpuInstanceWithPlacement.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceCreateGpuInstanceWithPlacementCalls())
|
|
func (mock *Interface) DeviceCreateGpuInstanceWithPlacementCalls() []struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
GpuInstancePlacement *nvml.GpuInstancePlacement
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
GpuInstancePlacement *nvml.GpuInstancePlacement
|
|
}
|
|
mock.lockDeviceCreateGpuInstanceWithPlacement.RLock()
|
|
calls = mock.calls.DeviceCreateGpuInstanceWithPlacement
|
|
mock.lockDeviceCreateGpuInstanceWithPlacement.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceDiscoverGpus calls DeviceDiscoverGpusFunc.
|
|
func (mock *Interface) DeviceDiscoverGpus() (nvml.PciInfo, nvml.Return) {
|
|
if mock.DeviceDiscoverGpusFunc == nil {
|
|
panic("Interface.DeviceDiscoverGpusFunc: method is nil but Interface.DeviceDiscoverGpus was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockDeviceDiscoverGpus.Lock()
|
|
mock.calls.DeviceDiscoverGpus = append(mock.calls.DeviceDiscoverGpus, callInfo)
|
|
mock.lockDeviceDiscoverGpus.Unlock()
|
|
return mock.DeviceDiscoverGpusFunc()
|
|
}
|
|
|
|
// DeviceDiscoverGpusCalls gets all the calls that were made to DeviceDiscoverGpus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceDiscoverGpusCalls())
|
|
func (mock *Interface) DeviceDiscoverGpusCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockDeviceDiscoverGpus.RLock()
|
|
calls = mock.calls.DeviceDiscoverGpus
|
|
mock.lockDeviceDiscoverGpus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceFreezeNvLinkUtilizationCounter calls DeviceFreezeNvLinkUtilizationCounterFunc.
|
|
func (mock *Interface) DeviceFreezeNvLinkUtilizationCounter(device nvml.Device, n1 int, n2 int, enableState nvml.EnableState) nvml.Return {
|
|
if mock.DeviceFreezeNvLinkUtilizationCounterFunc == nil {
|
|
panic("Interface.DeviceFreezeNvLinkUtilizationCounterFunc: method is nil but Interface.DeviceFreezeNvLinkUtilizationCounter was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
EnableState nvml.EnableState
|
|
}{
|
|
Device: device,
|
|
N1: n1,
|
|
N2: n2,
|
|
EnableState: enableState,
|
|
}
|
|
mock.lockDeviceFreezeNvLinkUtilizationCounter.Lock()
|
|
mock.calls.DeviceFreezeNvLinkUtilizationCounter = append(mock.calls.DeviceFreezeNvLinkUtilizationCounter, callInfo)
|
|
mock.lockDeviceFreezeNvLinkUtilizationCounter.Unlock()
|
|
return mock.DeviceFreezeNvLinkUtilizationCounterFunc(device, n1, n2, enableState)
|
|
}
|
|
|
|
// DeviceFreezeNvLinkUtilizationCounterCalls gets all the calls that were made to DeviceFreezeNvLinkUtilizationCounter.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceFreezeNvLinkUtilizationCounterCalls())
|
|
func (mock *Interface) DeviceFreezeNvLinkUtilizationCounterCalls() []struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
EnableState nvml.EnableState
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
EnableState nvml.EnableState
|
|
}
|
|
mock.lockDeviceFreezeNvLinkUtilizationCounter.RLock()
|
|
calls = mock.calls.DeviceFreezeNvLinkUtilizationCounter
|
|
mock.lockDeviceFreezeNvLinkUtilizationCounter.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetAPIRestriction calls DeviceGetAPIRestrictionFunc.
|
|
func (mock *Interface) DeviceGetAPIRestriction(device nvml.Device, restrictedAPI nvml.RestrictedAPI) (nvml.EnableState, nvml.Return) {
|
|
if mock.DeviceGetAPIRestrictionFunc == nil {
|
|
panic("Interface.DeviceGetAPIRestrictionFunc: method is nil but Interface.DeviceGetAPIRestriction was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
}{
|
|
Device: device,
|
|
RestrictedAPI: restrictedAPI,
|
|
}
|
|
mock.lockDeviceGetAPIRestriction.Lock()
|
|
mock.calls.DeviceGetAPIRestriction = append(mock.calls.DeviceGetAPIRestriction, callInfo)
|
|
mock.lockDeviceGetAPIRestriction.Unlock()
|
|
return mock.DeviceGetAPIRestrictionFunc(device, restrictedAPI)
|
|
}
|
|
|
|
// DeviceGetAPIRestrictionCalls gets all the calls that were made to DeviceGetAPIRestriction.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetAPIRestrictionCalls())
|
|
func (mock *Interface) DeviceGetAPIRestrictionCalls() []struct {
|
|
Device nvml.Device
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
}
|
|
mock.lockDeviceGetAPIRestriction.RLock()
|
|
calls = mock.calls.DeviceGetAPIRestriction
|
|
mock.lockDeviceGetAPIRestriction.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetAccountingBufferSize calls DeviceGetAccountingBufferSizeFunc.
|
|
func (mock *Interface) DeviceGetAccountingBufferSize(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetAccountingBufferSizeFunc == nil {
|
|
panic("Interface.DeviceGetAccountingBufferSizeFunc: method is nil but Interface.DeviceGetAccountingBufferSize was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetAccountingBufferSize.Lock()
|
|
mock.calls.DeviceGetAccountingBufferSize = append(mock.calls.DeviceGetAccountingBufferSize, callInfo)
|
|
mock.lockDeviceGetAccountingBufferSize.Unlock()
|
|
return mock.DeviceGetAccountingBufferSizeFunc(device)
|
|
}
|
|
|
|
// DeviceGetAccountingBufferSizeCalls gets all the calls that were made to DeviceGetAccountingBufferSize.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetAccountingBufferSizeCalls())
|
|
func (mock *Interface) DeviceGetAccountingBufferSizeCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetAccountingBufferSize.RLock()
|
|
calls = mock.calls.DeviceGetAccountingBufferSize
|
|
mock.lockDeviceGetAccountingBufferSize.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetAccountingMode calls DeviceGetAccountingModeFunc.
|
|
func (mock *Interface) DeviceGetAccountingMode(device nvml.Device) (nvml.EnableState, nvml.Return) {
|
|
if mock.DeviceGetAccountingModeFunc == nil {
|
|
panic("Interface.DeviceGetAccountingModeFunc: method is nil but Interface.DeviceGetAccountingMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetAccountingMode.Lock()
|
|
mock.calls.DeviceGetAccountingMode = append(mock.calls.DeviceGetAccountingMode, callInfo)
|
|
mock.lockDeviceGetAccountingMode.Unlock()
|
|
return mock.DeviceGetAccountingModeFunc(device)
|
|
}
|
|
|
|
// DeviceGetAccountingModeCalls gets all the calls that were made to DeviceGetAccountingMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetAccountingModeCalls())
|
|
func (mock *Interface) DeviceGetAccountingModeCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetAccountingMode.RLock()
|
|
calls = mock.calls.DeviceGetAccountingMode
|
|
mock.lockDeviceGetAccountingMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetAccountingPids calls DeviceGetAccountingPidsFunc.
|
|
func (mock *Interface) DeviceGetAccountingPids(device nvml.Device) ([]int, nvml.Return) {
|
|
if mock.DeviceGetAccountingPidsFunc == nil {
|
|
panic("Interface.DeviceGetAccountingPidsFunc: method is nil but Interface.DeviceGetAccountingPids was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetAccountingPids.Lock()
|
|
mock.calls.DeviceGetAccountingPids = append(mock.calls.DeviceGetAccountingPids, callInfo)
|
|
mock.lockDeviceGetAccountingPids.Unlock()
|
|
return mock.DeviceGetAccountingPidsFunc(device)
|
|
}
|
|
|
|
// DeviceGetAccountingPidsCalls gets all the calls that were made to DeviceGetAccountingPids.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetAccountingPidsCalls())
|
|
func (mock *Interface) DeviceGetAccountingPidsCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetAccountingPids.RLock()
|
|
calls = mock.calls.DeviceGetAccountingPids
|
|
mock.lockDeviceGetAccountingPids.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetAccountingStats calls DeviceGetAccountingStatsFunc.
|
|
func (mock *Interface) DeviceGetAccountingStats(device nvml.Device, v uint32) (nvml.AccountingStats, nvml.Return) {
|
|
if mock.DeviceGetAccountingStatsFunc == nil {
|
|
panic("Interface.DeviceGetAccountingStatsFunc: method is nil but Interface.DeviceGetAccountingStats was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
V uint32
|
|
}{
|
|
Device: device,
|
|
V: v,
|
|
}
|
|
mock.lockDeviceGetAccountingStats.Lock()
|
|
mock.calls.DeviceGetAccountingStats = append(mock.calls.DeviceGetAccountingStats, callInfo)
|
|
mock.lockDeviceGetAccountingStats.Unlock()
|
|
return mock.DeviceGetAccountingStatsFunc(device, v)
|
|
}
|
|
|
|
// DeviceGetAccountingStatsCalls gets all the calls that were made to DeviceGetAccountingStats.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetAccountingStatsCalls())
|
|
func (mock *Interface) DeviceGetAccountingStatsCalls() []struct {
|
|
Device nvml.Device
|
|
V uint32
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
V uint32
|
|
}
|
|
mock.lockDeviceGetAccountingStats.RLock()
|
|
calls = mock.calls.DeviceGetAccountingStats
|
|
mock.lockDeviceGetAccountingStats.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetActiveVgpus calls DeviceGetActiveVgpusFunc.
|
|
func (mock *Interface) DeviceGetActiveVgpus(device nvml.Device) ([]nvml.VgpuInstance, nvml.Return) {
|
|
if mock.DeviceGetActiveVgpusFunc == nil {
|
|
panic("Interface.DeviceGetActiveVgpusFunc: method is nil but Interface.DeviceGetActiveVgpus was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetActiveVgpus.Lock()
|
|
mock.calls.DeviceGetActiveVgpus = append(mock.calls.DeviceGetActiveVgpus, callInfo)
|
|
mock.lockDeviceGetActiveVgpus.Unlock()
|
|
return mock.DeviceGetActiveVgpusFunc(device)
|
|
}
|
|
|
|
// DeviceGetActiveVgpusCalls gets all the calls that were made to DeviceGetActiveVgpus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetActiveVgpusCalls())
|
|
func (mock *Interface) DeviceGetActiveVgpusCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetActiveVgpus.RLock()
|
|
calls = mock.calls.DeviceGetActiveVgpus
|
|
mock.lockDeviceGetActiveVgpus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetAdaptiveClockInfoStatus calls DeviceGetAdaptiveClockInfoStatusFunc.
|
|
func (mock *Interface) DeviceGetAdaptiveClockInfoStatus(device nvml.Device) (uint32, nvml.Return) {
|
|
if mock.DeviceGetAdaptiveClockInfoStatusFunc == nil {
|
|
panic("Interface.DeviceGetAdaptiveClockInfoStatusFunc: method is nil but Interface.DeviceGetAdaptiveClockInfoStatus was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetAdaptiveClockInfoStatus.Lock()
|
|
mock.calls.DeviceGetAdaptiveClockInfoStatus = append(mock.calls.DeviceGetAdaptiveClockInfoStatus, callInfo)
|
|
mock.lockDeviceGetAdaptiveClockInfoStatus.Unlock()
|
|
return mock.DeviceGetAdaptiveClockInfoStatusFunc(device)
|
|
}
|
|
|
|
// DeviceGetAdaptiveClockInfoStatusCalls gets all the calls that were made to DeviceGetAdaptiveClockInfoStatus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetAdaptiveClockInfoStatusCalls())
|
|
func (mock *Interface) DeviceGetAdaptiveClockInfoStatusCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetAdaptiveClockInfoStatus.RLock()
|
|
calls = mock.calls.DeviceGetAdaptiveClockInfoStatus
|
|
mock.lockDeviceGetAdaptiveClockInfoStatus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetApplicationsClock calls DeviceGetApplicationsClockFunc.
|
|
func (mock *Interface) DeviceGetApplicationsClock(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
if mock.DeviceGetApplicationsClockFunc == nil {
|
|
panic("Interface.DeviceGetApplicationsClockFunc: method is nil but Interface.DeviceGetApplicationsClock was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
}{
|
|
Device: device,
|
|
ClockType: clockType,
|
|
}
|
|
mock.lockDeviceGetApplicationsClock.Lock()
|
|
mock.calls.DeviceGetApplicationsClock = append(mock.calls.DeviceGetApplicationsClock, callInfo)
|
|
mock.lockDeviceGetApplicationsClock.Unlock()
|
|
return mock.DeviceGetApplicationsClockFunc(device, clockType)
|
|
}
|
|
|
|
// DeviceGetApplicationsClockCalls gets all the calls that were made to DeviceGetApplicationsClock.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetApplicationsClockCalls())
|
|
func (mock *Interface) DeviceGetApplicationsClockCalls() []struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
}
|
|
mock.lockDeviceGetApplicationsClock.RLock()
|
|
calls = mock.calls.DeviceGetApplicationsClock
|
|
mock.lockDeviceGetApplicationsClock.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetArchitecture calls DeviceGetArchitectureFunc.
|
|
func (mock *Interface) DeviceGetArchitecture(device nvml.Device) (nvml.DeviceArchitecture, nvml.Return) {
|
|
if mock.DeviceGetArchitectureFunc == nil {
|
|
panic("Interface.DeviceGetArchitectureFunc: method is nil but Interface.DeviceGetArchitecture was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetArchitecture.Lock()
|
|
mock.calls.DeviceGetArchitecture = append(mock.calls.DeviceGetArchitecture, callInfo)
|
|
mock.lockDeviceGetArchitecture.Unlock()
|
|
return mock.DeviceGetArchitectureFunc(device)
|
|
}
|
|
|
|
// DeviceGetArchitectureCalls gets all the calls that were made to DeviceGetArchitecture.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetArchitectureCalls())
|
|
func (mock *Interface) DeviceGetArchitectureCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetArchitecture.RLock()
|
|
calls = mock.calls.DeviceGetArchitecture
|
|
mock.lockDeviceGetArchitecture.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetAttributes calls DeviceGetAttributesFunc.
|
|
func (mock *Interface) DeviceGetAttributes(device nvml.Device) (nvml.DeviceAttributes, nvml.Return) {
|
|
if mock.DeviceGetAttributesFunc == nil {
|
|
panic("Interface.DeviceGetAttributesFunc: method is nil but Interface.DeviceGetAttributes was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetAttributes.Lock()
|
|
mock.calls.DeviceGetAttributes = append(mock.calls.DeviceGetAttributes, callInfo)
|
|
mock.lockDeviceGetAttributes.Unlock()
|
|
return mock.DeviceGetAttributesFunc(device)
|
|
}
|
|
|
|
// DeviceGetAttributesCalls gets all the calls that were made to DeviceGetAttributes.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetAttributesCalls())
|
|
func (mock *Interface) DeviceGetAttributesCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetAttributes.RLock()
|
|
calls = mock.calls.DeviceGetAttributes
|
|
mock.lockDeviceGetAttributes.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetAutoBoostedClocksEnabled calls DeviceGetAutoBoostedClocksEnabledFunc.
|
|
func (mock *Interface) DeviceGetAutoBoostedClocksEnabled(device nvml.Device) (nvml.EnableState, nvml.EnableState, nvml.Return) {
|
|
if mock.DeviceGetAutoBoostedClocksEnabledFunc == nil {
|
|
panic("Interface.DeviceGetAutoBoostedClocksEnabledFunc: method is nil but Interface.DeviceGetAutoBoostedClocksEnabled was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetAutoBoostedClocksEnabled.Lock()
|
|
mock.calls.DeviceGetAutoBoostedClocksEnabled = append(mock.calls.DeviceGetAutoBoostedClocksEnabled, callInfo)
|
|
mock.lockDeviceGetAutoBoostedClocksEnabled.Unlock()
|
|
return mock.DeviceGetAutoBoostedClocksEnabledFunc(device)
|
|
}
|
|
|
|
// DeviceGetAutoBoostedClocksEnabledCalls gets all the calls that were made to DeviceGetAutoBoostedClocksEnabled.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetAutoBoostedClocksEnabledCalls())
|
|
func (mock *Interface) DeviceGetAutoBoostedClocksEnabledCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetAutoBoostedClocksEnabled.RLock()
|
|
calls = mock.calls.DeviceGetAutoBoostedClocksEnabled
|
|
mock.lockDeviceGetAutoBoostedClocksEnabled.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetBAR1MemoryInfo calls DeviceGetBAR1MemoryInfoFunc.
|
|
func (mock *Interface) DeviceGetBAR1MemoryInfo(device nvml.Device) (nvml.BAR1Memory, nvml.Return) {
|
|
if mock.DeviceGetBAR1MemoryInfoFunc == nil {
|
|
panic("Interface.DeviceGetBAR1MemoryInfoFunc: method is nil but Interface.DeviceGetBAR1MemoryInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetBAR1MemoryInfo.Lock()
|
|
mock.calls.DeviceGetBAR1MemoryInfo = append(mock.calls.DeviceGetBAR1MemoryInfo, callInfo)
|
|
mock.lockDeviceGetBAR1MemoryInfo.Unlock()
|
|
return mock.DeviceGetBAR1MemoryInfoFunc(device)
|
|
}
|
|
|
|
// DeviceGetBAR1MemoryInfoCalls gets all the calls that were made to DeviceGetBAR1MemoryInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetBAR1MemoryInfoCalls())
|
|
func (mock *Interface) DeviceGetBAR1MemoryInfoCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetBAR1MemoryInfo.RLock()
|
|
calls = mock.calls.DeviceGetBAR1MemoryInfo
|
|
mock.lockDeviceGetBAR1MemoryInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetBoardId calls DeviceGetBoardIdFunc.
|
|
func (mock *Interface) DeviceGetBoardId(device nvml.Device) (uint32, nvml.Return) {
|
|
if mock.DeviceGetBoardIdFunc == nil {
|
|
panic("Interface.DeviceGetBoardIdFunc: method is nil but Interface.DeviceGetBoardId was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetBoardId.Lock()
|
|
mock.calls.DeviceGetBoardId = append(mock.calls.DeviceGetBoardId, callInfo)
|
|
mock.lockDeviceGetBoardId.Unlock()
|
|
return mock.DeviceGetBoardIdFunc(device)
|
|
}
|
|
|
|
// DeviceGetBoardIdCalls gets all the calls that were made to DeviceGetBoardId.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetBoardIdCalls())
|
|
func (mock *Interface) DeviceGetBoardIdCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetBoardId.RLock()
|
|
calls = mock.calls.DeviceGetBoardId
|
|
mock.lockDeviceGetBoardId.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetBoardPartNumber calls DeviceGetBoardPartNumberFunc.
|
|
func (mock *Interface) DeviceGetBoardPartNumber(device nvml.Device) (string, nvml.Return) {
|
|
if mock.DeviceGetBoardPartNumberFunc == nil {
|
|
panic("Interface.DeviceGetBoardPartNumberFunc: method is nil but Interface.DeviceGetBoardPartNumber was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetBoardPartNumber.Lock()
|
|
mock.calls.DeviceGetBoardPartNumber = append(mock.calls.DeviceGetBoardPartNumber, callInfo)
|
|
mock.lockDeviceGetBoardPartNumber.Unlock()
|
|
return mock.DeviceGetBoardPartNumberFunc(device)
|
|
}
|
|
|
|
// DeviceGetBoardPartNumberCalls gets all the calls that were made to DeviceGetBoardPartNumber.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetBoardPartNumberCalls())
|
|
func (mock *Interface) DeviceGetBoardPartNumberCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetBoardPartNumber.RLock()
|
|
calls = mock.calls.DeviceGetBoardPartNumber
|
|
mock.lockDeviceGetBoardPartNumber.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetBrand calls DeviceGetBrandFunc.
|
|
func (mock *Interface) DeviceGetBrand(device nvml.Device) (nvml.BrandType, nvml.Return) {
|
|
if mock.DeviceGetBrandFunc == nil {
|
|
panic("Interface.DeviceGetBrandFunc: method is nil but Interface.DeviceGetBrand was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetBrand.Lock()
|
|
mock.calls.DeviceGetBrand = append(mock.calls.DeviceGetBrand, callInfo)
|
|
mock.lockDeviceGetBrand.Unlock()
|
|
return mock.DeviceGetBrandFunc(device)
|
|
}
|
|
|
|
// DeviceGetBrandCalls gets all the calls that were made to DeviceGetBrand.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetBrandCalls())
|
|
func (mock *Interface) DeviceGetBrandCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetBrand.RLock()
|
|
calls = mock.calls.DeviceGetBrand
|
|
mock.lockDeviceGetBrand.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetBridgeChipInfo calls DeviceGetBridgeChipInfoFunc.
|
|
func (mock *Interface) DeviceGetBridgeChipInfo(device nvml.Device) (nvml.BridgeChipHierarchy, nvml.Return) {
|
|
if mock.DeviceGetBridgeChipInfoFunc == nil {
|
|
panic("Interface.DeviceGetBridgeChipInfoFunc: method is nil but Interface.DeviceGetBridgeChipInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetBridgeChipInfo.Lock()
|
|
mock.calls.DeviceGetBridgeChipInfo = append(mock.calls.DeviceGetBridgeChipInfo, callInfo)
|
|
mock.lockDeviceGetBridgeChipInfo.Unlock()
|
|
return mock.DeviceGetBridgeChipInfoFunc(device)
|
|
}
|
|
|
|
// DeviceGetBridgeChipInfoCalls gets all the calls that were made to DeviceGetBridgeChipInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetBridgeChipInfoCalls())
|
|
func (mock *Interface) DeviceGetBridgeChipInfoCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetBridgeChipInfo.RLock()
|
|
calls = mock.calls.DeviceGetBridgeChipInfo
|
|
mock.lockDeviceGetBridgeChipInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetBusType calls DeviceGetBusTypeFunc.
|
|
func (mock *Interface) DeviceGetBusType(device nvml.Device) (nvml.BusType, nvml.Return) {
|
|
if mock.DeviceGetBusTypeFunc == nil {
|
|
panic("Interface.DeviceGetBusTypeFunc: method is nil but Interface.DeviceGetBusType was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetBusType.Lock()
|
|
mock.calls.DeviceGetBusType = append(mock.calls.DeviceGetBusType, callInfo)
|
|
mock.lockDeviceGetBusType.Unlock()
|
|
return mock.DeviceGetBusTypeFunc(device)
|
|
}
|
|
|
|
// DeviceGetBusTypeCalls gets all the calls that were made to DeviceGetBusType.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetBusTypeCalls())
|
|
func (mock *Interface) DeviceGetBusTypeCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetBusType.RLock()
|
|
calls = mock.calls.DeviceGetBusType
|
|
mock.lockDeviceGetBusType.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetClkMonStatus calls DeviceGetClkMonStatusFunc.
|
|
func (mock *Interface) DeviceGetClkMonStatus(device nvml.Device) (nvml.ClkMonStatus, nvml.Return) {
|
|
if mock.DeviceGetClkMonStatusFunc == nil {
|
|
panic("Interface.DeviceGetClkMonStatusFunc: method is nil but Interface.DeviceGetClkMonStatus was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetClkMonStatus.Lock()
|
|
mock.calls.DeviceGetClkMonStatus = append(mock.calls.DeviceGetClkMonStatus, callInfo)
|
|
mock.lockDeviceGetClkMonStatus.Unlock()
|
|
return mock.DeviceGetClkMonStatusFunc(device)
|
|
}
|
|
|
|
// DeviceGetClkMonStatusCalls gets all the calls that were made to DeviceGetClkMonStatus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetClkMonStatusCalls())
|
|
func (mock *Interface) DeviceGetClkMonStatusCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetClkMonStatus.RLock()
|
|
calls = mock.calls.DeviceGetClkMonStatus
|
|
mock.lockDeviceGetClkMonStatus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetClock calls DeviceGetClockFunc.
|
|
func (mock *Interface) DeviceGetClock(device nvml.Device, clockType nvml.ClockType, clockId nvml.ClockId) (uint32, nvml.Return) {
|
|
if mock.DeviceGetClockFunc == nil {
|
|
panic("Interface.DeviceGetClockFunc: method is nil but Interface.DeviceGetClock was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
ClockId nvml.ClockId
|
|
}{
|
|
Device: device,
|
|
ClockType: clockType,
|
|
ClockId: clockId,
|
|
}
|
|
mock.lockDeviceGetClock.Lock()
|
|
mock.calls.DeviceGetClock = append(mock.calls.DeviceGetClock, callInfo)
|
|
mock.lockDeviceGetClock.Unlock()
|
|
return mock.DeviceGetClockFunc(device, clockType, clockId)
|
|
}
|
|
|
|
// DeviceGetClockCalls gets all the calls that were made to DeviceGetClock.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetClockCalls())
|
|
func (mock *Interface) DeviceGetClockCalls() []struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
ClockId nvml.ClockId
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
ClockId nvml.ClockId
|
|
}
|
|
mock.lockDeviceGetClock.RLock()
|
|
calls = mock.calls.DeviceGetClock
|
|
mock.lockDeviceGetClock.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetClockInfo calls DeviceGetClockInfoFunc.
|
|
func (mock *Interface) DeviceGetClockInfo(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
if mock.DeviceGetClockInfoFunc == nil {
|
|
panic("Interface.DeviceGetClockInfoFunc: method is nil but Interface.DeviceGetClockInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
}{
|
|
Device: device,
|
|
ClockType: clockType,
|
|
}
|
|
mock.lockDeviceGetClockInfo.Lock()
|
|
mock.calls.DeviceGetClockInfo = append(mock.calls.DeviceGetClockInfo, callInfo)
|
|
mock.lockDeviceGetClockInfo.Unlock()
|
|
return mock.DeviceGetClockInfoFunc(device, clockType)
|
|
}
|
|
|
|
// DeviceGetClockInfoCalls gets all the calls that were made to DeviceGetClockInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetClockInfoCalls())
|
|
func (mock *Interface) DeviceGetClockInfoCalls() []struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
}
|
|
mock.lockDeviceGetClockInfo.RLock()
|
|
calls = mock.calls.DeviceGetClockInfo
|
|
mock.lockDeviceGetClockInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetComputeInstanceId calls DeviceGetComputeInstanceIdFunc.
|
|
func (mock *Interface) DeviceGetComputeInstanceId(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetComputeInstanceIdFunc == nil {
|
|
panic("Interface.DeviceGetComputeInstanceIdFunc: method is nil but Interface.DeviceGetComputeInstanceId was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetComputeInstanceId.Lock()
|
|
mock.calls.DeviceGetComputeInstanceId = append(mock.calls.DeviceGetComputeInstanceId, callInfo)
|
|
mock.lockDeviceGetComputeInstanceId.Unlock()
|
|
return mock.DeviceGetComputeInstanceIdFunc(device)
|
|
}
|
|
|
|
// DeviceGetComputeInstanceIdCalls gets all the calls that were made to DeviceGetComputeInstanceId.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetComputeInstanceIdCalls())
|
|
func (mock *Interface) DeviceGetComputeInstanceIdCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetComputeInstanceId.RLock()
|
|
calls = mock.calls.DeviceGetComputeInstanceId
|
|
mock.lockDeviceGetComputeInstanceId.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetComputeMode calls DeviceGetComputeModeFunc.
|
|
func (mock *Interface) DeviceGetComputeMode(device nvml.Device) (nvml.ComputeMode, nvml.Return) {
|
|
if mock.DeviceGetComputeModeFunc == nil {
|
|
panic("Interface.DeviceGetComputeModeFunc: method is nil but Interface.DeviceGetComputeMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetComputeMode.Lock()
|
|
mock.calls.DeviceGetComputeMode = append(mock.calls.DeviceGetComputeMode, callInfo)
|
|
mock.lockDeviceGetComputeMode.Unlock()
|
|
return mock.DeviceGetComputeModeFunc(device)
|
|
}
|
|
|
|
// DeviceGetComputeModeCalls gets all the calls that were made to DeviceGetComputeMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetComputeModeCalls())
|
|
func (mock *Interface) DeviceGetComputeModeCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetComputeMode.RLock()
|
|
calls = mock.calls.DeviceGetComputeMode
|
|
mock.lockDeviceGetComputeMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetComputeRunningProcesses calls DeviceGetComputeRunningProcessesFunc.
|
|
func (mock *Interface) DeviceGetComputeRunningProcesses(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return) {
|
|
if mock.DeviceGetComputeRunningProcessesFunc == nil {
|
|
panic("Interface.DeviceGetComputeRunningProcessesFunc: method is nil but Interface.DeviceGetComputeRunningProcesses was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetComputeRunningProcesses.Lock()
|
|
mock.calls.DeviceGetComputeRunningProcesses = append(mock.calls.DeviceGetComputeRunningProcesses, callInfo)
|
|
mock.lockDeviceGetComputeRunningProcesses.Unlock()
|
|
return mock.DeviceGetComputeRunningProcessesFunc(device)
|
|
}
|
|
|
|
// DeviceGetComputeRunningProcessesCalls gets all the calls that were made to DeviceGetComputeRunningProcesses.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetComputeRunningProcessesCalls())
|
|
func (mock *Interface) DeviceGetComputeRunningProcessesCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetComputeRunningProcesses.RLock()
|
|
calls = mock.calls.DeviceGetComputeRunningProcesses
|
|
mock.lockDeviceGetComputeRunningProcesses.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetCount calls DeviceGetCountFunc.
|
|
func (mock *Interface) DeviceGetCount() (int, nvml.Return) {
|
|
if mock.DeviceGetCountFunc == nil {
|
|
panic("Interface.DeviceGetCountFunc: method is nil but Interface.DeviceGetCount was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockDeviceGetCount.Lock()
|
|
mock.calls.DeviceGetCount = append(mock.calls.DeviceGetCount, callInfo)
|
|
mock.lockDeviceGetCount.Unlock()
|
|
return mock.DeviceGetCountFunc()
|
|
}
|
|
|
|
// DeviceGetCountCalls gets all the calls that were made to DeviceGetCount.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetCountCalls())
|
|
func (mock *Interface) DeviceGetCountCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockDeviceGetCount.RLock()
|
|
calls = mock.calls.DeviceGetCount
|
|
mock.lockDeviceGetCount.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetCpuAffinity calls DeviceGetCpuAffinityFunc.
|
|
func (mock *Interface) DeviceGetCpuAffinity(device nvml.Device, n int) ([]uint, nvml.Return) {
|
|
if mock.DeviceGetCpuAffinityFunc == nil {
|
|
panic("Interface.DeviceGetCpuAffinityFunc: method is nil but Interface.DeviceGetCpuAffinity was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceGetCpuAffinity.Lock()
|
|
mock.calls.DeviceGetCpuAffinity = append(mock.calls.DeviceGetCpuAffinity, callInfo)
|
|
mock.lockDeviceGetCpuAffinity.Unlock()
|
|
return mock.DeviceGetCpuAffinityFunc(device, n)
|
|
}
|
|
|
|
// DeviceGetCpuAffinityCalls gets all the calls that were made to DeviceGetCpuAffinity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetCpuAffinityCalls())
|
|
func (mock *Interface) DeviceGetCpuAffinityCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceGetCpuAffinity.RLock()
|
|
calls = mock.calls.DeviceGetCpuAffinity
|
|
mock.lockDeviceGetCpuAffinity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetCpuAffinityWithinScope calls DeviceGetCpuAffinityWithinScopeFunc.
|
|
func (mock *Interface) DeviceGetCpuAffinityWithinScope(device nvml.Device, n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return) {
|
|
if mock.DeviceGetCpuAffinityWithinScopeFunc == nil {
|
|
panic("Interface.DeviceGetCpuAffinityWithinScopeFunc: method is nil but Interface.DeviceGetCpuAffinityWithinScope was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
AffinityScope nvml.AffinityScope
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
AffinityScope: affinityScope,
|
|
}
|
|
mock.lockDeviceGetCpuAffinityWithinScope.Lock()
|
|
mock.calls.DeviceGetCpuAffinityWithinScope = append(mock.calls.DeviceGetCpuAffinityWithinScope, callInfo)
|
|
mock.lockDeviceGetCpuAffinityWithinScope.Unlock()
|
|
return mock.DeviceGetCpuAffinityWithinScopeFunc(device, n, affinityScope)
|
|
}
|
|
|
|
// DeviceGetCpuAffinityWithinScopeCalls gets all the calls that were made to DeviceGetCpuAffinityWithinScope.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetCpuAffinityWithinScopeCalls())
|
|
func (mock *Interface) DeviceGetCpuAffinityWithinScopeCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
AffinityScope nvml.AffinityScope
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
AffinityScope nvml.AffinityScope
|
|
}
|
|
mock.lockDeviceGetCpuAffinityWithinScope.RLock()
|
|
calls = mock.calls.DeviceGetCpuAffinityWithinScope
|
|
mock.lockDeviceGetCpuAffinityWithinScope.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetCreatableVgpus calls DeviceGetCreatableVgpusFunc.
|
|
func (mock *Interface) DeviceGetCreatableVgpus(device nvml.Device) ([]nvml.VgpuTypeId, nvml.Return) {
|
|
if mock.DeviceGetCreatableVgpusFunc == nil {
|
|
panic("Interface.DeviceGetCreatableVgpusFunc: method is nil but Interface.DeviceGetCreatableVgpus was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetCreatableVgpus.Lock()
|
|
mock.calls.DeviceGetCreatableVgpus = append(mock.calls.DeviceGetCreatableVgpus, callInfo)
|
|
mock.lockDeviceGetCreatableVgpus.Unlock()
|
|
return mock.DeviceGetCreatableVgpusFunc(device)
|
|
}
|
|
|
|
// DeviceGetCreatableVgpusCalls gets all the calls that were made to DeviceGetCreatableVgpus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetCreatableVgpusCalls())
|
|
func (mock *Interface) DeviceGetCreatableVgpusCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetCreatableVgpus.RLock()
|
|
calls = mock.calls.DeviceGetCreatableVgpus
|
|
mock.lockDeviceGetCreatableVgpus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetCudaComputeCapability calls DeviceGetCudaComputeCapabilityFunc.
|
|
func (mock *Interface) DeviceGetCudaComputeCapability(device nvml.Device) (int, int, nvml.Return) {
|
|
if mock.DeviceGetCudaComputeCapabilityFunc == nil {
|
|
panic("Interface.DeviceGetCudaComputeCapabilityFunc: method is nil but Interface.DeviceGetCudaComputeCapability was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetCudaComputeCapability.Lock()
|
|
mock.calls.DeviceGetCudaComputeCapability = append(mock.calls.DeviceGetCudaComputeCapability, callInfo)
|
|
mock.lockDeviceGetCudaComputeCapability.Unlock()
|
|
return mock.DeviceGetCudaComputeCapabilityFunc(device)
|
|
}
|
|
|
|
// DeviceGetCudaComputeCapabilityCalls gets all the calls that were made to DeviceGetCudaComputeCapability.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetCudaComputeCapabilityCalls())
|
|
func (mock *Interface) DeviceGetCudaComputeCapabilityCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetCudaComputeCapability.RLock()
|
|
calls = mock.calls.DeviceGetCudaComputeCapability
|
|
mock.lockDeviceGetCudaComputeCapability.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetCurrPcieLinkGeneration calls DeviceGetCurrPcieLinkGenerationFunc.
|
|
func (mock *Interface) DeviceGetCurrPcieLinkGeneration(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetCurrPcieLinkGenerationFunc == nil {
|
|
panic("Interface.DeviceGetCurrPcieLinkGenerationFunc: method is nil but Interface.DeviceGetCurrPcieLinkGeneration was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetCurrPcieLinkGeneration.Lock()
|
|
mock.calls.DeviceGetCurrPcieLinkGeneration = append(mock.calls.DeviceGetCurrPcieLinkGeneration, callInfo)
|
|
mock.lockDeviceGetCurrPcieLinkGeneration.Unlock()
|
|
return mock.DeviceGetCurrPcieLinkGenerationFunc(device)
|
|
}
|
|
|
|
// DeviceGetCurrPcieLinkGenerationCalls gets all the calls that were made to DeviceGetCurrPcieLinkGeneration.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetCurrPcieLinkGenerationCalls())
|
|
func (mock *Interface) DeviceGetCurrPcieLinkGenerationCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetCurrPcieLinkGeneration.RLock()
|
|
calls = mock.calls.DeviceGetCurrPcieLinkGeneration
|
|
mock.lockDeviceGetCurrPcieLinkGeneration.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetCurrPcieLinkWidth calls DeviceGetCurrPcieLinkWidthFunc.
|
|
func (mock *Interface) DeviceGetCurrPcieLinkWidth(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetCurrPcieLinkWidthFunc == nil {
|
|
panic("Interface.DeviceGetCurrPcieLinkWidthFunc: method is nil but Interface.DeviceGetCurrPcieLinkWidth was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetCurrPcieLinkWidth.Lock()
|
|
mock.calls.DeviceGetCurrPcieLinkWidth = append(mock.calls.DeviceGetCurrPcieLinkWidth, callInfo)
|
|
mock.lockDeviceGetCurrPcieLinkWidth.Unlock()
|
|
return mock.DeviceGetCurrPcieLinkWidthFunc(device)
|
|
}
|
|
|
|
// DeviceGetCurrPcieLinkWidthCalls gets all the calls that were made to DeviceGetCurrPcieLinkWidth.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetCurrPcieLinkWidthCalls())
|
|
func (mock *Interface) DeviceGetCurrPcieLinkWidthCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetCurrPcieLinkWidth.RLock()
|
|
calls = mock.calls.DeviceGetCurrPcieLinkWidth
|
|
mock.lockDeviceGetCurrPcieLinkWidth.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetCurrentClocksThrottleReasons calls DeviceGetCurrentClocksThrottleReasonsFunc.
|
|
func (mock *Interface) DeviceGetCurrentClocksThrottleReasons(device nvml.Device) (uint64, nvml.Return) {
|
|
if mock.DeviceGetCurrentClocksThrottleReasonsFunc == nil {
|
|
panic("Interface.DeviceGetCurrentClocksThrottleReasonsFunc: method is nil but Interface.DeviceGetCurrentClocksThrottleReasons was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetCurrentClocksThrottleReasons.Lock()
|
|
mock.calls.DeviceGetCurrentClocksThrottleReasons = append(mock.calls.DeviceGetCurrentClocksThrottleReasons, callInfo)
|
|
mock.lockDeviceGetCurrentClocksThrottleReasons.Unlock()
|
|
return mock.DeviceGetCurrentClocksThrottleReasonsFunc(device)
|
|
}
|
|
|
|
// DeviceGetCurrentClocksThrottleReasonsCalls gets all the calls that were made to DeviceGetCurrentClocksThrottleReasons.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetCurrentClocksThrottleReasonsCalls())
|
|
func (mock *Interface) DeviceGetCurrentClocksThrottleReasonsCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetCurrentClocksThrottleReasons.RLock()
|
|
calls = mock.calls.DeviceGetCurrentClocksThrottleReasons
|
|
mock.lockDeviceGetCurrentClocksThrottleReasons.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetDecoderUtilization calls DeviceGetDecoderUtilizationFunc.
|
|
func (mock *Interface) DeviceGetDecoderUtilization(device nvml.Device) (uint32, uint32, nvml.Return) {
|
|
if mock.DeviceGetDecoderUtilizationFunc == nil {
|
|
panic("Interface.DeviceGetDecoderUtilizationFunc: method is nil but Interface.DeviceGetDecoderUtilization was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetDecoderUtilization.Lock()
|
|
mock.calls.DeviceGetDecoderUtilization = append(mock.calls.DeviceGetDecoderUtilization, callInfo)
|
|
mock.lockDeviceGetDecoderUtilization.Unlock()
|
|
return mock.DeviceGetDecoderUtilizationFunc(device)
|
|
}
|
|
|
|
// DeviceGetDecoderUtilizationCalls gets all the calls that were made to DeviceGetDecoderUtilization.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetDecoderUtilizationCalls())
|
|
func (mock *Interface) DeviceGetDecoderUtilizationCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetDecoderUtilization.RLock()
|
|
calls = mock.calls.DeviceGetDecoderUtilization
|
|
mock.lockDeviceGetDecoderUtilization.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetDefaultApplicationsClock calls DeviceGetDefaultApplicationsClockFunc.
|
|
func (mock *Interface) DeviceGetDefaultApplicationsClock(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
if mock.DeviceGetDefaultApplicationsClockFunc == nil {
|
|
panic("Interface.DeviceGetDefaultApplicationsClockFunc: method is nil but Interface.DeviceGetDefaultApplicationsClock was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
}{
|
|
Device: device,
|
|
ClockType: clockType,
|
|
}
|
|
mock.lockDeviceGetDefaultApplicationsClock.Lock()
|
|
mock.calls.DeviceGetDefaultApplicationsClock = append(mock.calls.DeviceGetDefaultApplicationsClock, callInfo)
|
|
mock.lockDeviceGetDefaultApplicationsClock.Unlock()
|
|
return mock.DeviceGetDefaultApplicationsClockFunc(device, clockType)
|
|
}
|
|
|
|
// DeviceGetDefaultApplicationsClockCalls gets all the calls that were made to DeviceGetDefaultApplicationsClock.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetDefaultApplicationsClockCalls())
|
|
func (mock *Interface) DeviceGetDefaultApplicationsClockCalls() []struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
}
|
|
mock.lockDeviceGetDefaultApplicationsClock.RLock()
|
|
calls = mock.calls.DeviceGetDefaultApplicationsClock
|
|
mock.lockDeviceGetDefaultApplicationsClock.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetDefaultEccMode calls DeviceGetDefaultEccModeFunc.
|
|
func (mock *Interface) DeviceGetDefaultEccMode(device nvml.Device) (nvml.EnableState, nvml.Return) {
|
|
if mock.DeviceGetDefaultEccModeFunc == nil {
|
|
panic("Interface.DeviceGetDefaultEccModeFunc: method is nil but Interface.DeviceGetDefaultEccMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetDefaultEccMode.Lock()
|
|
mock.calls.DeviceGetDefaultEccMode = append(mock.calls.DeviceGetDefaultEccMode, callInfo)
|
|
mock.lockDeviceGetDefaultEccMode.Unlock()
|
|
return mock.DeviceGetDefaultEccModeFunc(device)
|
|
}
|
|
|
|
// DeviceGetDefaultEccModeCalls gets all the calls that were made to DeviceGetDefaultEccMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetDefaultEccModeCalls())
|
|
func (mock *Interface) DeviceGetDefaultEccModeCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetDefaultEccMode.RLock()
|
|
calls = mock.calls.DeviceGetDefaultEccMode
|
|
mock.lockDeviceGetDefaultEccMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetDetailedEccErrors calls DeviceGetDetailedEccErrorsFunc.
|
|
func (mock *Interface) DeviceGetDetailedEccErrors(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (nvml.EccErrorCounts, nvml.Return) {
|
|
if mock.DeviceGetDetailedEccErrorsFunc == nil {
|
|
panic("Interface.DeviceGetDetailedEccErrorsFunc: method is nil but Interface.DeviceGetDetailedEccErrors was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
}{
|
|
Device: device,
|
|
MemoryErrorType: memoryErrorType,
|
|
EccCounterType: eccCounterType,
|
|
}
|
|
mock.lockDeviceGetDetailedEccErrors.Lock()
|
|
mock.calls.DeviceGetDetailedEccErrors = append(mock.calls.DeviceGetDetailedEccErrors, callInfo)
|
|
mock.lockDeviceGetDetailedEccErrors.Unlock()
|
|
return mock.DeviceGetDetailedEccErrorsFunc(device, memoryErrorType, eccCounterType)
|
|
}
|
|
|
|
// DeviceGetDetailedEccErrorsCalls gets all the calls that were made to DeviceGetDetailedEccErrors.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetDetailedEccErrorsCalls())
|
|
func (mock *Interface) DeviceGetDetailedEccErrorsCalls() []struct {
|
|
Device nvml.Device
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
}
|
|
mock.lockDeviceGetDetailedEccErrors.RLock()
|
|
calls = mock.calls.DeviceGetDetailedEccErrors
|
|
mock.lockDeviceGetDetailedEccErrors.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetDeviceHandleFromMigDeviceHandle calls DeviceGetDeviceHandleFromMigDeviceHandleFunc.
|
|
func (mock *Interface) DeviceGetDeviceHandleFromMigDeviceHandle(device nvml.Device) (nvml.Device, nvml.Return) {
|
|
if mock.DeviceGetDeviceHandleFromMigDeviceHandleFunc == nil {
|
|
panic("Interface.DeviceGetDeviceHandleFromMigDeviceHandleFunc: method is nil but Interface.DeviceGetDeviceHandleFromMigDeviceHandle was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetDeviceHandleFromMigDeviceHandle.Lock()
|
|
mock.calls.DeviceGetDeviceHandleFromMigDeviceHandle = append(mock.calls.DeviceGetDeviceHandleFromMigDeviceHandle, callInfo)
|
|
mock.lockDeviceGetDeviceHandleFromMigDeviceHandle.Unlock()
|
|
return mock.DeviceGetDeviceHandleFromMigDeviceHandleFunc(device)
|
|
}
|
|
|
|
// DeviceGetDeviceHandleFromMigDeviceHandleCalls gets all the calls that were made to DeviceGetDeviceHandleFromMigDeviceHandle.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetDeviceHandleFromMigDeviceHandleCalls())
|
|
func (mock *Interface) DeviceGetDeviceHandleFromMigDeviceHandleCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetDeviceHandleFromMigDeviceHandle.RLock()
|
|
calls = mock.calls.DeviceGetDeviceHandleFromMigDeviceHandle
|
|
mock.lockDeviceGetDeviceHandleFromMigDeviceHandle.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetDisplayActive calls DeviceGetDisplayActiveFunc.
|
|
func (mock *Interface) DeviceGetDisplayActive(device nvml.Device) (nvml.EnableState, nvml.Return) {
|
|
if mock.DeviceGetDisplayActiveFunc == nil {
|
|
panic("Interface.DeviceGetDisplayActiveFunc: method is nil but Interface.DeviceGetDisplayActive was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetDisplayActive.Lock()
|
|
mock.calls.DeviceGetDisplayActive = append(mock.calls.DeviceGetDisplayActive, callInfo)
|
|
mock.lockDeviceGetDisplayActive.Unlock()
|
|
return mock.DeviceGetDisplayActiveFunc(device)
|
|
}
|
|
|
|
// DeviceGetDisplayActiveCalls gets all the calls that were made to DeviceGetDisplayActive.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetDisplayActiveCalls())
|
|
func (mock *Interface) DeviceGetDisplayActiveCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetDisplayActive.RLock()
|
|
calls = mock.calls.DeviceGetDisplayActive
|
|
mock.lockDeviceGetDisplayActive.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetDisplayMode calls DeviceGetDisplayModeFunc.
|
|
func (mock *Interface) DeviceGetDisplayMode(device nvml.Device) (nvml.EnableState, nvml.Return) {
|
|
if mock.DeviceGetDisplayModeFunc == nil {
|
|
panic("Interface.DeviceGetDisplayModeFunc: method is nil but Interface.DeviceGetDisplayMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetDisplayMode.Lock()
|
|
mock.calls.DeviceGetDisplayMode = append(mock.calls.DeviceGetDisplayMode, callInfo)
|
|
mock.lockDeviceGetDisplayMode.Unlock()
|
|
return mock.DeviceGetDisplayModeFunc(device)
|
|
}
|
|
|
|
// DeviceGetDisplayModeCalls gets all the calls that were made to DeviceGetDisplayMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetDisplayModeCalls())
|
|
func (mock *Interface) DeviceGetDisplayModeCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetDisplayMode.RLock()
|
|
calls = mock.calls.DeviceGetDisplayMode
|
|
mock.lockDeviceGetDisplayMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetDriverModel calls DeviceGetDriverModelFunc.
|
|
func (mock *Interface) DeviceGetDriverModel(device nvml.Device) (nvml.DriverModel, nvml.DriverModel, nvml.Return) {
|
|
if mock.DeviceGetDriverModelFunc == nil {
|
|
panic("Interface.DeviceGetDriverModelFunc: method is nil but Interface.DeviceGetDriverModel was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetDriverModel.Lock()
|
|
mock.calls.DeviceGetDriverModel = append(mock.calls.DeviceGetDriverModel, callInfo)
|
|
mock.lockDeviceGetDriverModel.Unlock()
|
|
return mock.DeviceGetDriverModelFunc(device)
|
|
}
|
|
|
|
// DeviceGetDriverModelCalls gets all the calls that were made to DeviceGetDriverModel.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetDriverModelCalls())
|
|
func (mock *Interface) DeviceGetDriverModelCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetDriverModel.RLock()
|
|
calls = mock.calls.DeviceGetDriverModel
|
|
mock.lockDeviceGetDriverModel.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetDynamicPstatesInfo calls DeviceGetDynamicPstatesInfoFunc.
|
|
func (mock *Interface) DeviceGetDynamicPstatesInfo(device nvml.Device) (nvml.GpuDynamicPstatesInfo, nvml.Return) {
|
|
if mock.DeviceGetDynamicPstatesInfoFunc == nil {
|
|
panic("Interface.DeviceGetDynamicPstatesInfoFunc: method is nil but Interface.DeviceGetDynamicPstatesInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetDynamicPstatesInfo.Lock()
|
|
mock.calls.DeviceGetDynamicPstatesInfo = append(mock.calls.DeviceGetDynamicPstatesInfo, callInfo)
|
|
mock.lockDeviceGetDynamicPstatesInfo.Unlock()
|
|
return mock.DeviceGetDynamicPstatesInfoFunc(device)
|
|
}
|
|
|
|
// DeviceGetDynamicPstatesInfoCalls gets all the calls that were made to DeviceGetDynamicPstatesInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetDynamicPstatesInfoCalls())
|
|
func (mock *Interface) DeviceGetDynamicPstatesInfoCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetDynamicPstatesInfo.RLock()
|
|
calls = mock.calls.DeviceGetDynamicPstatesInfo
|
|
mock.lockDeviceGetDynamicPstatesInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetEccMode calls DeviceGetEccModeFunc.
|
|
func (mock *Interface) DeviceGetEccMode(device nvml.Device) (nvml.EnableState, nvml.EnableState, nvml.Return) {
|
|
if mock.DeviceGetEccModeFunc == nil {
|
|
panic("Interface.DeviceGetEccModeFunc: method is nil but Interface.DeviceGetEccMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetEccMode.Lock()
|
|
mock.calls.DeviceGetEccMode = append(mock.calls.DeviceGetEccMode, callInfo)
|
|
mock.lockDeviceGetEccMode.Unlock()
|
|
return mock.DeviceGetEccModeFunc(device)
|
|
}
|
|
|
|
// DeviceGetEccModeCalls gets all the calls that were made to DeviceGetEccMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetEccModeCalls())
|
|
func (mock *Interface) DeviceGetEccModeCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetEccMode.RLock()
|
|
calls = mock.calls.DeviceGetEccMode
|
|
mock.lockDeviceGetEccMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetEncoderCapacity calls DeviceGetEncoderCapacityFunc.
|
|
func (mock *Interface) DeviceGetEncoderCapacity(device nvml.Device, encoderType nvml.EncoderType) (int, nvml.Return) {
|
|
if mock.DeviceGetEncoderCapacityFunc == nil {
|
|
panic("Interface.DeviceGetEncoderCapacityFunc: method is nil but Interface.DeviceGetEncoderCapacity was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
EncoderType nvml.EncoderType
|
|
}{
|
|
Device: device,
|
|
EncoderType: encoderType,
|
|
}
|
|
mock.lockDeviceGetEncoderCapacity.Lock()
|
|
mock.calls.DeviceGetEncoderCapacity = append(mock.calls.DeviceGetEncoderCapacity, callInfo)
|
|
mock.lockDeviceGetEncoderCapacity.Unlock()
|
|
return mock.DeviceGetEncoderCapacityFunc(device, encoderType)
|
|
}
|
|
|
|
// DeviceGetEncoderCapacityCalls gets all the calls that were made to DeviceGetEncoderCapacity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetEncoderCapacityCalls())
|
|
func (mock *Interface) DeviceGetEncoderCapacityCalls() []struct {
|
|
Device nvml.Device
|
|
EncoderType nvml.EncoderType
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
EncoderType nvml.EncoderType
|
|
}
|
|
mock.lockDeviceGetEncoderCapacity.RLock()
|
|
calls = mock.calls.DeviceGetEncoderCapacity
|
|
mock.lockDeviceGetEncoderCapacity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetEncoderSessions calls DeviceGetEncoderSessionsFunc.
|
|
func (mock *Interface) DeviceGetEncoderSessions(device nvml.Device) ([]nvml.EncoderSessionInfo, nvml.Return) {
|
|
if mock.DeviceGetEncoderSessionsFunc == nil {
|
|
panic("Interface.DeviceGetEncoderSessionsFunc: method is nil but Interface.DeviceGetEncoderSessions was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetEncoderSessions.Lock()
|
|
mock.calls.DeviceGetEncoderSessions = append(mock.calls.DeviceGetEncoderSessions, callInfo)
|
|
mock.lockDeviceGetEncoderSessions.Unlock()
|
|
return mock.DeviceGetEncoderSessionsFunc(device)
|
|
}
|
|
|
|
// DeviceGetEncoderSessionsCalls gets all the calls that were made to DeviceGetEncoderSessions.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetEncoderSessionsCalls())
|
|
func (mock *Interface) DeviceGetEncoderSessionsCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetEncoderSessions.RLock()
|
|
calls = mock.calls.DeviceGetEncoderSessions
|
|
mock.lockDeviceGetEncoderSessions.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetEncoderStats calls DeviceGetEncoderStatsFunc.
|
|
func (mock *Interface) DeviceGetEncoderStats(device nvml.Device) (int, uint32, uint32, nvml.Return) {
|
|
if mock.DeviceGetEncoderStatsFunc == nil {
|
|
panic("Interface.DeviceGetEncoderStatsFunc: method is nil but Interface.DeviceGetEncoderStats was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetEncoderStats.Lock()
|
|
mock.calls.DeviceGetEncoderStats = append(mock.calls.DeviceGetEncoderStats, callInfo)
|
|
mock.lockDeviceGetEncoderStats.Unlock()
|
|
return mock.DeviceGetEncoderStatsFunc(device)
|
|
}
|
|
|
|
// DeviceGetEncoderStatsCalls gets all the calls that were made to DeviceGetEncoderStats.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetEncoderStatsCalls())
|
|
func (mock *Interface) DeviceGetEncoderStatsCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetEncoderStats.RLock()
|
|
calls = mock.calls.DeviceGetEncoderStats
|
|
mock.lockDeviceGetEncoderStats.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetEncoderUtilization calls DeviceGetEncoderUtilizationFunc.
|
|
func (mock *Interface) DeviceGetEncoderUtilization(device nvml.Device) (uint32, uint32, nvml.Return) {
|
|
if mock.DeviceGetEncoderUtilizationFunc == nil {
|
|
panic("Interface.DeviceGetEncoderUtilizationFunc: method is nil but Interface.DeviceGetEncoderUtilization was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetEncoderUtilization.Lock()
|
|
mock.calls.DeviceGetEncoderUtilization = append(mock.calls.DeviceGetEncoderUtilization, callInfo)
|
|
mock.lockDeviceGetEncoderUtilization.Unlock()
|
|
return mock.DeviceGetEncoderUtilizationFunc(device)
|
|
}
|
|
|
|
// DeviceGetEncoderUtilizationCalls gets all the calls that were made to DeviceGetEncoderUtilization.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetEncoderUtilizationCalls())
|
|
func (mock *Interface) DeviceGetEncoderUtilizationCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetEncoderUtilization.RLock()
|
|
calls = mock.calls.DeviceGetEncoderUtilization
|
|
mock.lockDeviceGetEncoderUtilization.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetEnforcedPowerLimit calls DeviceGetEnforcedPowerLimitFunc.
|
|
func (mock *Interface) DeviceGetEnforcedPowerLimit(device nvml.Device) (uint32, nvml.Return) {
|
|
if mock.DeviceGetEnforcedPowerLimitFunc == nil {
|
|
panic("Interface.DeviceGetEnforcedPowerLimitFunc: method is nil but Interface.DeviceGetEnforcedPowerLimit was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetEnforcedPowerLimit.Lock()
|
|
mock.calls.DeviceGetEnforcedPowerLimit = append(mock.calls.DeviceGetEnforcedPowerLimit, callInfo)
|
|
mock.lockDeviceGetEnforcedPowerLimit.Unlock()
|
|
return mock.DeviceGetEnforcedPowerLimitFunc(device)
|
|
}
|
|
|
|
// DeviceGetEnforcedPowerLimitCalls gets all the calls that were made to DeviceGetEnforcedPowerLimit.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetEnforcedPowerLimitCalls())
|
|
func (mock *Interface) DeviceGetEnforcedPowerLimitCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetEnforcedPowerLimit.RLock()
|
|
calls = mock.calls.DeviceGetEnforcedPowerLimit
|
|
mock.lockDeviceGetEnforcedPowerLimit.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetFBCSessions calls DeviceGetFBCSessionsFunc.
|
|
func (mock *Interface) DeviceGetFBCSessions(device nvml.Device) ([]nvml.FBCSessionInfo, nvml.Return) {
|
|
if mock.DeviceGetFBCSessionsFunc == nil {
|
|
panic("Interface.DeviceGetFBCSessionsFunc: method is nil but Interface.DeviceGetFBCSessions was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetFBCSessions.Lock()
|
|
mock.calls.DeviceGetFBCSessions = append(mock.calls.DeviceGetFBCSessions, callInfo)
|
|
mock.lockDeviceGetFBCSessions.Unlock()
|
|
return mock.DeviceGetFBCSessionsFunc(device)
|
|
}
|
|
|
|
// DeviceGetFBCSessionsCalls gets all the calls that were made to DeviceGetFBCSessions.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetFBCSessionsCalls())
|
|
func (mock *Interface) DeviceGetFBCSessionsCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetFBCSessions.RLock()
|
|
calls = mock.calls.DeviceGetFBCSessions
|
|
mock.lockDeviceGetFBCSessions.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetFBCStats calls DeviceGetFBCStatsFunc.
|
|
func (mock *Interface) DeviceGetFBCStats(device nvml.Device) (nvml.FBCStats, nvml.Return) {
|
|
if mock.DeviceGetFBCStatsFunc == nil {
|
|
panic("Interface.DeviceGetFBCStatsFunc: method is nil but Interface.DeviceGetFBCStats was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetFBCStats.Lock()
|
|
mock.calls.DeviceGetFBCStats = append(mock.calls.DeviceGetFBCStats, callInfo)
|
|
mock.lockDeviceGetFBCStats.Unlock()
|
|
return mock.DeviceGetFBCStatsFunc(device)
|
|
}
|
|
|
|
// DeviceGetFBCStatsCalls gets all the calls that were made to DeviceGetFBCStats.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetFBCStatsCalls())
|
|
func (mock *Interface) DeviceGetFBCStatsCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetFBCStats.RLock()
|
|
calls = mock.calls.DeviceGetFBCStats
|
|
mock.lockDeviceGetFBCStats.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetFanControlPolicy_v2 calls DeviceGetFanControlPolicy_v2Func.
|
|
func (mock *Interface) DeviceGetFanControlPolicy_v2(device nvml.Device, n int) (nvml.FanControlPolicy, nvml.Return) {
|
|
if mock.DeviceGetFanControlPolicy_v2Func == nil {
|
|
panic("Interface.DeviceGetFanControlPolicy_v2Func: method is nil but Interface.DeviceGetFanControlPolicy_v2 was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceGetFanControlPolicy_v2.Lock()
|
|
mock.calls.DeviceGetFanControlPolicy_v2 = append(mock.calls.DeviceGetFanControlPolicy_v2, callInfo)
|
|
mock.lockDeviceGetFanControlPolicy_v2.Unlock()
|
|
return mock.DeviceGetFanControlPolicy_v2Func(device, n)
|
|
}
|
|
|
|
// DeviceGetFanControlPolicy_v2Calls gets all the calls that were made to DeviceGetFanControlPolicy_v2.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetFanControlPolicy_v2Calls())
|
|
func (mock *Interface) DeviceGetFanControlPolicy_v2Calls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceGetFanControlPolicy_v2.RLock()
|
|
calls = mock.calls.DeviceGetFanControlPolicy_v2
|
|
mock.lockDeviceGetFanControlPolicy_v2.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetFanSpeed calls DeviceGetFanSpeedFunc.
|
|
func (mock *Interface) DeviceGetFanSpeed(device nvml.Device) (uint32, nvml.Return) {
|
|
if mock.DeviceGetFanSpeedFunc == nil {
|
|
panic("Interface.DeviceGetFanSpeedFunc: method is nil but Interface.DeviceGetFanSpeed was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetFanSpeed.Lock()
|
|
mock.calls.DeviceGetFanSpeed = append(mock.calls.DeviceGetFanSpeed, callInfo)
|
|
mock.lockDeviceGetFanSpeed.Unlock()
|
|
return mock.DeviceGetFanSpeedFunc(device)
|
|
}
|
|
|
|
// DeviceGetFanSpeedCalls gets all the calls that were made to DeviceGetFanSpeed.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetFanSpeedCalls())
|
|
func (mock *Interface) DeviceGetFanSpeedCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetFanSpeed.RLock()
|
|
calls = mock.calls.DeviceGetFanSpeed
|
|
mock.lockDeviceGetFanSpeed.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetFanSpeed_v2 calls DeviceGetFanSpeed_v2Func.
|
|
func (mock *Interface) DeviceGetFanSpeed_v2(device nvml.Device, n int) (uint32, nvml.Return) {
|
|
if mock.DeviceGetFanSpeed_v2Func == nil {
|
|
panic("Interface.DeviceGetFanSpeed_v2Func: method is nil but Interface.DeviceGetFanSpeed_v2 was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceGetFanSpeed_v2.Lock()
|
|
mock.calls.DeviceGetFanSpeed_v2 = append(mock.calls.DeviceGetFanSpeed_v2, callInfo)
|
|
mock.lockDeviceGetFanSpeed_v2.Unlock()
|
|
return mock.DeviceGetFanSpeed_v2Func(device, n)
|
|
}
|
|
|
|
// DeviceGetFanSpeed_v2Calls gets all the calls that were made to DeviceGetFanSpeed_v2.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetFanSpeed_v2Calls())
|
|
func (mock *Interface) DeviceGetFanSpeed_v2Calls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceGetFanSpeed_v2.RLock()
|
|
calls = mock.calls.DeviceGetFanSpeed_v2
|
|
mock.lockDeviceGetFanSpeed_v2.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetFieldValues calls DeviceGetFieldValuesFunc.
|
|
func (mock *Interface) DeviceGetFieldValues(device nvml.Device, fieldValues []nvml.FieldValue) nvml.Return {
|
|
if mock.DeviceGetFieldValuesFunc == nil {
|
|
panic("Interface.DeviceGetFieldValuesFunc: method is nil but Interface.DeviceGetFieldValues was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
FieldValues []nvml.FieldValue
|
|
}{
|
|
Device: device,
|
|
FieldValues: fieldValues,
|
|
}
|
|
mock.lockDeviceGetFieldValues.Lock()
|
|
mock.calls.DeviceGetFieldValues = append(mock.calls.DeviceGetFieldValues, callInfo)
|
|
mock.lockDeviceGetFieldValues.Unlock()
|
|
return mock.DeviceGetFieldValuesFunc(device, fieldValues)
|
|
}
|
|
|
|
// DeviceGetFieldValuesCalls gets all the calls that were made to DeviceGetFieldValues.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetFieldValuesCalls())
|
|
func (mock *Interface) DeviceGetFieldValuesCalls() []struct {
|
|
Device nvml.Device
|
|
FieldValues []nvml.FieldValue
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
FieldValues []nvml.FieldValue
|
|
}
|
|
mock.lockDeviceGetFieldValues.RLock()
|
|
calls = mock.calls.DeviceGetFieldValues
|
|
mock.lockDeviceGetFieldValues.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGpcClkMinMaxVfOffset calls DeviceGetGpcClkMinMaxVfOffsetFunc.
|
|
func (mock *Interface) DeviceGetGpcClkMinMaxVfOffset(device nvml.Device) (int, int, nvml.Return) {
|
|
if mock.DeviceGetGpcClkMinMaxVfOffsetFunc == nil {
|
|
panic("Interface.DeviceGetGpcClkMinMaxVfOffsetFunc: method is nil but Interface.DeviceGetGpcClkMinMaxVfOffset was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetGpcClkMinMaxVfOffset.Lock()
|
|
mock.calls.DeviceGetGpcClkMinMaxVfOffset = append(mock.calls.DeviceGetGpcClkMinMaxVfOffset, callInfo)
|
|
mock.lockDeviceGetGpcClkMinMaxVfOffset.Unlock()
|
|
return mock.DeviceGetGpcClkMinMaxVfOffsetFunc(device)
|
|
}
|
|
|
|
// DeviceGetGpcClkMinMaxVfOffsetCalls gets all the calls that were made to DeviceGetGpcClkMinMaxVfOffset.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGpcClkMinMaxVfOffsetCalls())
|
|
func (mock *Interface) DeviceGetGpcClkMinMaxVfOffsetCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetGpcClkMinMaxVfOffset.RLock()
|
|
calls = mock.calls.DeviceGetGpcClkMinMaxVfOffset
|
|
mock.lockDeviceGetGpcClkMinMaxVfOffset.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGpcClkVfOffset calls DeviceGetGpcClkVfOffsetFunc.
|
|
func (mock *Interface) DeviceGetGpcClkVfOffset(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetGpcClkVfOffsetFunc == nil {
|
|
panic("Interface.DeviceGetGpcClkVfOffsetFunc: method is nil but Interface.DeviceGetGpcClkVfOffset was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetGpcClkVfOffset.Lock()
|
|
mock.calls.DeviceGetGpcClkVfOffset = append(mock.calls.DeviceGetGpcClkVfOffset, callInfo)
|
|
mock.lockDeviceGetGpcClkVfOffset.Unlock()
|
|
return mock.DeviceGetGpcClkVfOffsetFunc(device)
|
|
}
|
|
|
|
// DeviceGetGpcClkVfOffsetCalls gets all the calls that were made to DeviceGetGpcClkVfOffset.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGpcClkVfOffsetCalls())
|
|
func (mock *Interface) DeviceGetGpcClkVfOffsetCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetGpcClkVfOffset.RLock()
|
|
calls = mock.calls.DeviceGetGpcClkVfOffset
|
|
mock.lockDeviceGetGpcClkVfOffset.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGpuFabricInfo calls DeviceGetGpuFabricInfoFunc.
|
|
func (mock *Interface) DeviceGetGpuFabricInfo(device nvml.Device) (nvml.GpuFabricInfo, nvml.Return) {
|
|
if mock.DeviceGetGpuFabricInfoFunc == nil {
|
|
panic("Interface.DeviceGetGpuFabricInfoFunc: method is nil but Interface.DeviceGetGpuFabricInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetGpuFabricInfo.Lock()
|
|
mock.calls.DeviceGetGpuFabricInfo = append(mock.calls.DeviceGetGpuFabricInfo, callInfo)
|
|
mock.lockDeviceGetGpuFabricInfo.Unlock()
|
|
return mock.DeviceGetGpuFabricInfoFunc(device)
|
|
}
|
|
|
|
// DeviceGetGpuFabricInfoCalls gets all the calls that were made to DeviceGetGpuFabricInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGpuFabricInfoCalls())
|
|
func (mock *Interface) DeviceGetGpuFabricInfoCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetGpuFabricInfo.RLock()
|
|
calls = mock.calls.DeviceGetGpuFabricInfo
|
|
mock.lockDeviceGetGpuFabricInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGpuInstanceById calls DeviceGetGpuInstanceByIdFunc.
|
|
func (mock *Interface) DeviceGetGpuInstanceById(device nvml.Device, n int) (nvml.GpuInstance, nvml.Return) {
|
|
if mock.DeviceGetGpuInstanceByIdFunc == nil {
|
|
panic("Interface.DeviceGetGpuInstanceByIdFunc: method is nil but Interface.DeviceGetGpuInstanceById was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceGetGpuInstanceById.Lock()
|
|
mock.calls.DeviceGetGpuInstanceById = append(mock.calls.DeviceGetGpuInstanceById, callInfo)
|
|
mock.lockDeviceGetGpuInstanceById.Unlock()
|
|
return mock.DeviceGetGpuInstanceByIdFunc(device, n)
|
|
}
|
|
|
|
// DeviceGetGpuInstanceByIdCalls gets all the calls that were made to DeviceGetGpuInstanceById.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGpuInstanceByIdCalls())
|
|
func (mock *Interface) DeviceGetGpuInstanceByIdCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceGetGpuInstanceById.RLock()
|
|
calls = mock.calls.DeviceGetGpuInstanceById
|
|
mock.lockDeviceGetGpuInstanceById.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGpuInstanceId calls DeviceGetGpuInstanceIdFunc.
|
|
func (mock *Interface) DeviceGetGpuInstanceId(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetGpuInstanceIdFunc == nil {
|
|
panic("Interface.DeviceGetGpuInstanceIdFunc: method is nil but Interface.DeviceGetGpuInstanceId was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetGpuInstanceId.Lock()
|
|
mock.calls.DeviceGetGpuInstanceId = append(mock.calls.DeviceGetGpuInstanceId, callInfo)
|
|
mock.lockDeviceGetGpuInstanceId.Unlock()
|
|
return mock.DeviceGetGpuInstanceIdFunc(device)
|
|
}
|
|
|
|
// DeviceGetGpuInstanceIdCalls gets all the calls that were made to DeviceGetGpuInstanceId.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGpuInstanceIdCalls())
|
|
func (mock *Interface) DeviceGetGpuInstanceIdCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetGpuInstanceId.RLock()
|
|
calls = mock.calls.DeviceGetGpuInstanceId
|
|
mock.lockDeviceGetGpuInstanceId.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGpuInstancePossiblePlacements calls DeviceGetGpuInstancePossiblePlacementsFunc.
|
|
func (mock *Interface) DeviceGetGpuInstancePossiblePlacements(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstancePlacement, nvml.Return) {
|
|
if mock.DeviceGetGpuInstancePossiblePlacementsFunc == nil {
|
|
panic("Interface.DeviceGetGpuInstancePossiblePlacementsFunc: method is nil but Interface.DeviceGetGpuInstancePossiblePlacements was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}{
|
|
Device: device,
|
|
GpuInstanceProfileInfo: gpuInstanceProfileInfo,
|
|
}
|
|
mock.lockDeviceGetGpuInstancePossiblePlacements.Lock()
|
|
mock.calls.DeviceGetGpuInstancePossiblePlacements = append(mock.calls.DeviceGetGpuInstancePossiblePlacements, callInfo)
|
|
mock.lockDeviceGetGpuInstancePossiblePlacements.Unlock()
|
|
return mock.DeviceGetGpuInstancePossiblePlacementsFunc(device, gpuInstanceProfileInfo)
|
|
}
|
|
|
|
// DeviceGetGpuInstancePossiblePlacementsCalls gets all the calls that were made to DeviceGetGpuInstancePossiblePlacements.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGpuInstancePossiblePlacementsCalls())
|
|
func (mock *Interface) DeviceGetGpuInstancePossiblePlacementsCalls() []struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
mock.lockDeviceGetGpuInstancePossiblePlacements.RLock()
|
|
calls = mock.calls.DeviceGetGpuInstancePossiblePlacements
|
|
mock.lockDeviceGetGpuInstancePossiblePlacements.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGpuInstanceProfileInfo calls DeviceGetGpuInstanceProfileInfoFunc.
|
|
func (mock *Interface) DeviceGetGpuInstanceProfileInfo(device nvml.Device, n int) (nvml.GpuInstanceProfileInfo, nvml.Return) {
|
|
if mock.DeviceGetGpuInstanceProfileInfoFunc == nil {
|
|
panic("Interface.DeviceGetGpuInstanceProfileInfoFunc: method is nil but Interface.DeviceGetGpuInstanceProfileInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceGetGpuInstanceProfileInfo.Lock()
|
|
mock.calls.DeviceGetGpuInstanceProfileInfo = append(mock.calls.DeviceGetGpuInstanceProfileInfo, callInfo)
|
|
mock.lockDeviceGetGpuInstanceProfileInfo.Unlock()
|
|
return mock.DeviceGetGpuInstanceProfileInfoFunc(device, n)
|
|
}
|
|
|
|
// DeviceGetGpuInstanceProfileInfoCalls gets all the calls that were made to DeviceGetGpuInstanceProfileInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGpuInstanceProfileInfoCalls())
|
|
func (mock *Interface) DeviceGetGpuInstanceProfileInfoCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceGetGpuInstanceProfileInfo.RLock()
|
|
calls = mock.calls.DeviceGetGpuInstanceProfileInfo
|
|
mock.lockDeviceGetGpuInstanceProfileInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGpuInstanceProfileInfoV calls DeviceGetGpuInstanceProfileInfoVFunc.
|
|
func (mock *Interface) DeviceGetGpuInstanceProfileInfoV(device nvml.Device, n int) nvml.GpuInstanceProfileInfoV {
|
|
if mock.DeviceGetGpuInstanceProfileInfoVFunc == nil {
|
|
panic("Interface.DeviceGetGpuInstanceProfileInfoVFunc: method is nil but Interface.DeviceGetGpuInstanceProfileInfoV was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceGetGpuInstanceProfileInfoV.Lock()
|
|
mock.calls.DeviceGetGpuInstanceProfileInfoV = append(mock.calls.DeviceGetGpuInstanceProfileInfoV, callInfo)
|
|
mock.lockDeviceGetGpuInstanceProfileInfoV.Unlock()
|
|
return mock.DeviceGetGpuInstanceProfileInfoVFunc(device, n)
|
|
}
|
|
|
|
// DeviceGetGpuInstanceProfileInfoVCalls gets all the calls that were made to DeviceGetGpuInstanceProfileInfoV.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGpuInstanceProfileInfoVCalls())
|
|
func (mock *Interface) DeviceGetGpuInstanceProfileInfoVCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceGetGpuInstanceProfileInfoV.RLock()
|
|
calls = mock.calls.DeviceGetGpuInstanceProfileInfoV
|
|
mock.lockDeviceGetGpuInstanceProfileInfoV.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGpuInstanceRemainingCapacity calls DeviceGetGpuInstanceRemainingCapacityFunc.
|
|
func (mock *Interface) DeviceGetGpuInstanceRemainingCapacity(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (int, nvml.Return) {
|
|
if mock.DeviceGetGpuInstanceRemainingCapacityFunc == nil {
|
|
panic("Interface.DeviceGetGpuInstanceRemainingCapacityFunc: method is nil but Interface.DeviceGetGpuInstanceRemainingCapacity was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}{
|
|
Device: device,
|
|
GpuInstanceProfileInfo: gpuInstanceProfileInfo,
|
|
}
|
|
mock.lockDeviceGetGpuInstanceRemainingCapacity.Lock()
|
|
mock.calls.DeviceGetGpuInstanceRemainingCapacity = append(mock.calls.DeviceGetGpuInstanceRemainingCapacity, callInfo)
|
|
mock.lockDeviceGetGpuInstanceRemainingCapacity.Unlock()
|
|
return mock.DeviceGetGpuInstanceRemainingCapacityFunc(device, gpuInstanceProfileInfo)
|
|
}
|
|
|
|
// DeviceGetGpuInstanceRemainingCapacityCalls gets all the calls that were made to DeviceGetGpuInstanceRemainingCapacity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGpuInstanceRemainingCapacityCalls())
|
|
func (mock *Interface) DeviceGetGpuInstanceRemainingCapacityCalls() []struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
mock.lockDeviceGetGpuInstanceRemainingCapacity.RLock()
|
|
calls = mock.calls.DeviceGetGpuInstanceRemainingCapacity
|
|
mock.lockDeviceGetGpuInstanceRemainingCapacity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGpuInstances calls DeviceGetGpuInstancesFunc.
|
|
func (mock *Interface) DeviceGetGpuInstances(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstance, nvml.Return) {
|
|
if mock.DeviceGetGpuInstancesFunc == nil {
|
|
panic("Interface.DeviceGetGpuInstancesFunc: method is nil but Interface.DeviceGetGpuInstances was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}{
|
|
Device: device,
|
|
GpuInstanceProfileInfo: gpuInstanceProfileInfo,
|
|
}
|
|
mock.lockDeviceGetGpuInstances.Lock()
|
|
mock.calls.DeviceGetGpuInstances = append(mock.calls.DeviceGetGpuInstances, callInfo)
|
|
mock.lockDeviceGetGpuInstances.Unlock()
|
|
return mock.DeviceGetGpuInstancesFunc(device, gpuInstanceProfileInfo)
|
|
}
|
|
|
|
// DeviceGetGpuInstancesCalls gets all the calls that were made to DeviceGetGpuInstances.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGpuInstancesCalls())
|
|
func (mock *Interface) DeviceGetGpuInstancesCalls() []struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
mock.lockDeviceGetGpuInstances.RLock()
|
|
calls = mock.calls.DeviceGetGpuInstances
|
|
mock.lockDeviceGetGpuInstances.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGpuMaxPcieLinkGeneration calls DeviceGetGpuMaxPcieLinkGenerationFunc.
|
|
func (mock *Interface) DeviceGetGpuMaxPcieLinkGeneration(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetGpuMaxPcieLinkGenerationFunc == nil {
|
|
panic("Interface.DeviceGetGpuMaxPcieLinkGenerationFunc: method is nil but Interface.DeviceGetGpuMaxPcieLinkGeneration was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetGpuMaxPcieLinkGeneration.Lock()
|
|
mock.calls.DeviceGetGpuMaxPcieLinkGeneration = append(mock.calls.DeviceGetGpuMaxPcieLinkGeneration, callInfo)
|
|
mock.lockDeviceGetGpuMaxPcieLinkGeneration.Unlock()
|
|
return mock.DeviceGetGpuMaxPcieLinkGenerationFunc(device)
|
|
}
|
|
|
|
// DeviceGetGpuMaxPcieLinkGenerationCalls gets all the calls that were made to DeviceGetGpuMaxPcieLinkGeneration.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGpuMaxPcieLinkGenerationCalls())
|
|
func (mock *Interface) DeviceGetGpuMaxPcieLinkGenerationCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetGpuMaxPcieLinkGeneration.RLock()
|
|
calls = mock.calls.DeviceGetGpuMaxPcieLinkGeneration
|
|
mock.lockDeviceGetGpuMaxPcieLinkGeneration.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGpuOperationMode calls DeviceGetGpuOperationModeFunc.
|
|
func (mock *Interface) DeviceGetGpuOperationMode(device nvml.Device) (nvml.GpuOperationMode, nvml.GpuOperationMode, nvml.Return) {
|
|
if mock.DeviceGetGpuOperationModeFunc == nil {
|
|
panic("Interface.DeviceGetGpuOperationModeFunc: method is nil but Interface.DeviceGetGpuOperationMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetGpuOperationMode.Lock()
|
|
mock.calls.DeviceGetGpuOperationMode = append(mock.calls.DeviceGetGpuOperationMode, callInfo)
|
|
mock.lockDeviceGetGpuOperationMode.Unlock()
|
|
return mock.DeviceGetGpuOperationModeFunc(device)
|
|
}
|
|
|
|
// DeviceGetGpuOperationModeCalls gets all the calls that were made to DeviceGetGpuOperationMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGpuOperationModeCalls())
|
|
func (mock *Interface) DeviceGetGpuOperationModeCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetGpuOperationMode.RLock()
|
|
calls = mock.calls.DeviceGetGpuOperationMode
|
|
mock.lockDeviceGetGpuOperationMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGraphicsRunningProcesses calls DeviceGetGraphicsRunningProcessesFunc.
|
|
func (mock *Interface) DeviceGetGraphicsRunningProcesses(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return) {
|
|
if mock.DeviceGetGraphicsRunningProcessesFunc == nil {
|
|
panic("Interface.DeviceGetGraphicsRunningProcessesFunc: method is nil but Interface.DeviceGetGraphicsRunningProcesses was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetGraphicsRunningProcesses.Lock()
|
|
mock.calls.DeviceGetGraphicsRunningProcesses = append(mock.calls.DeviceGetGraphicsRunningProcesses, callInfo)
|
|
mock.lockDeviceGetGraphicsRunningProcesses.Unlock()
|
|
return mock.DeviceGetGraphicsRunningProcessesFunc(device)
|
|
}
|
|
|
|
// DeviceGetGraphicsRunningProcessesCalls gets all the calls that were made to DeviceGetGraphicsRunningProcesses.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGraphicsRunningProcessesCalls())
|
|
func (mock *Interface) DeviceGetGraphicsRunningProcessesCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetGraphicsRunningProcesses.RLock()
|
|
calls = mock.calls.DeviceGetGraphicsRunningProcesses
|
|
mock.lockDeviceGetGraphicsRunningProcesses.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGridLicensableFeatures calls DeviceGetGridLicensableFeaturesFunc.
|
|
func (mock *Interface) DeviceGetGridLicensableFeatures(device nvml.Device) (nvml.GridLicensableFeatures, nvml.Return) {
|
|
if mock.DeviceGetGridLicensableFeaturesFunc == nil {
|
|
panic("Interface.DeviceGetGridLicensableFeaturesFunc: method is nil but Interface.DeviceGetGridLicensableFeatures was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetGridLicensableFeatures.Lock()
|
|
mock.calls.DeviceGetGridLicensableFeatures = append(mock.calls.DeviceGetGridLicensableFeatures, callInfo)
|
|
mock.lockDeviceGetGridLicensableFeatures.Unlock()
|
|
return mock.DeviceGetGridLicensableFeaturesFunc(device)
|
|
}
|
|
|
|
// DeviceGetGridLicensableFeaturesCalls gets all the calls that were made to DeviceGetGridLicensableFeatures.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGridLicensableFeaturesCalls())
|
|
func (mock *Interface) DeviceGetGridLicensableFeaturesCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetGridLicensableFeatures.RLock()
|
|
calls = mock.calls.DeviceGetGridLicensableFeatures
|
|
mock.lockDeviceGetGridLicensableFeatures.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGspFirmwareMode calls DeviceGetGspFirmwareModeFunc.
|
|
func (mock *Interface) DeviceGetGspFirmwareMode(device nvml.Device) (bool, bool, nvml.Return) {
|
|
if mock.DeviceGetGspFirmwareModeFunc == nil {
|
|
panic("Interface.DeviceGetGspFirmwareModeFunc: method is nil but Interface.DeviceGetGspFirmwareMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetGspFirmwareMode.Lock()
|
|
mock.calls.DeviceGetGspFirmwareMode = append(mock.calls.DeviceGetGspFirmwareMode, callInfo)
|
|
mock.lockDeviceGetGspFirmwareMode.Unlock()
|
|
return mock.DeviceGetGspFirmwareModeFunc(device)
|
|
}
|
|
|
|
// DeviceGetGspFirmwareModeCalls gets all the calls that were made to DeviceGetGspFirmwareMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGspFirmwareModeCalls())
|
|
func (mock *Interface) DeviceGetGspFirmwareModeCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetGspFirmwareMode.RLock()
|
|
calls = mock.calls.DeviceGetGspFirmwareMode
|
|
mock.lockDeviceGetGspFirmwareMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetGspFirmwareVersion calls DeviceGetGspFirmwareVersionFunc.
|
|
func (mock *Interface) DeviceGetGspFirmwareVersion(device nvml.Device) (string, nvml.Return) {
|
|
if mock.DeviceGetGspFirmwareVersionFunc == nil {
|
|
panic("Interface.DeviceGetGspFirmwareVersionFunc: method is nil but Interface.DeviceGetGspFirmwareVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetGspFirmwareVersion.Lock()
|
|
mock.calls.DeviceGetGspFirmwareVersion = append(mock.calls.DeviceGetGspFirmwareVersion, callInfo)
|
|
mock.lockDeviceGetGspFirmwareVersion.Unlock()
|
|
return mock.DeviceGetGspFirmwareVersionFunc(device)
|
|
}
|
|
|
|
// DeviceGetGspFirmwareVersionCalls gets all the calls that were made to DeviceGetGspFirmwareVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetGspFirmwareVersionCalls())
|
|
func (mock *Interface) DeviceGetGspFirmwareVersionCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetGspFirmwareVersion.RLock()
|
|
calls = mock.calls.DeviceGetGspFirmwareVersion
|
|
mock.lockDeviceGetGspFirmwareVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetHandleByIndex calls DeviceGetHandleByIndexFunc.
|
|
func (mock *Interface) DeviceGetHandleByIndex(n int) (nvml.Device, nvml.Return) {
|
|
if mock.DeviceGetHandleByIndexFunc == nil {
|
|
panic("Interface.DeviceGetHandleByIndexFunc: method is nil but Interface.DeviceGetHandleByIndex was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockDeviceGetHandleByIndex.Lock()
|
|
mock.calls.DeviceGetHandleByIndex = append(mock.calls.DeviceGetHandleByIndex, callInfo)
|
|
mock.lockDeviceGetHandleByIndex.Unlock()
|
|
return mock.DeviceGetHandleByIndexFunc(n)
|
|
}
|
|
|
|
// DeviceGetHandleByIndexCalls gets all the calls that were made to DeviceGetHandleByIndex.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetHandleByIndexCalls())
|
|
func (mock *Interface) DeviceGetHandleByIndexCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockDeviceGetHandleByIndex.RLock()
|
|
calls = mock.calls.DeviceGetHandleByIndex
|
|
mock.lockDeviceGetHandleByIndex.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetHandleByPciBusId calls DeviceGetHandleByPciBusIdFunc.
|
|
func (mock *Interface) DeviceGetHandleByPciBusId(s string) (nvml.Device, nvml.Return) {
|
|
if mock.DeviceGetHandleByPciBusIdFunc == nil {
|
|
panic("Interface.DeviceGetHandleByPciBusIdFunc: method is nil but Interface.DeviceGetHandleByPciBusId was just called")
|
|
}
|
|
callInfo := struct {
|
|
S string
|
|
}{
|
|
S: s,
|
|
}
|
|
mock.lockDeviceGetHandleByPciBusId.Lock()
|
|
mock.calls.DeviceGetHandleByPciBusId = append(mock.calls.DeviceGetHandleByPciBusId, callInfo)
|
|
mock.lockDeviceGetHandleByPciBusId.Unlock()
|
|
return mock.DeviceGetHandleByPciBusIdFunc(s)
|
|
}
|
|
|
|
// DeviceGetHandleByPciBusIdCalls gets all the calls that were made to DeviceGetHandleByPciBusId.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetHandleByPciBusIdCalls())
|
|
func (mock *Interface) DeviceGetHandleByPciBusIdCalls() []struct {
|
|
S string
|
|
} {
|
|
var calls []struct {
|
|
S string
|
|
}
|
|
mock.lockDeviceGetHandleByPciBusId.RLock()
|
|
calls = mock.calls.DeviceGetHandleByPciBusId
|
|
mock.lockDeviceGetHandleByPciBusId.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetHandleBySerial calls DeviceGetHandleBySerialFunc.
|
|
func (mock *Interface) DeviceGetHandleBySerial(s string) (nvml.Device, nvml.Return) {
|
|
if mock.DeviceGetHandleBySerialFunc == nil {
|
|
panic("Interface.DeviceGetHandleBySerialFunc: method is nil but Interface.DeviceGetHandleBySerial was just called")
|
|
}
|
|
callInfo := struct {
|
|
S string
|
|
}{
|
|
S: s,
|
|
}
|
|
mock.lockDeviceGetHandleBySerial.Lock()
|
|
mock.calls.DeviceGetHandleBySerial = append(mock.calls.DeviceGetHandleBySerial, callInfo)
|
|
mock.lockDeviceGetHandleBySerial.Unlock()
|
|
return mock.DeviceGetHandleBySerialFunc(s)
|
|
}
|
|
|
|
// DeviceGetHandleBySerialCalls gets all the calls that were made to DeviceGetHandleBySerial.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetHandleBySerialCalls())
|
|
func (mock *Interface) DeviceGetHandleBySerialCalls() []struct {
|
|
S string
|
|
} {
|
|
var calls []struct {
|
|
S string
|
|
}
|
|
mock.lockDeviceGetHandleBySerial.RLock()
|
|
calls = mock.calls.DeviceGetHandleBySerial
|
|
mock.lockDeviceGetHandleBySerial.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetHandleByUUID calls DeviceGetHandleByUUIDFunc.
|
|
func (mock *Interface) DeviceGetHandleByUUID(s string) (nvml.Device, nvml.Return) {
|
|
if mock.DeviceGetHandleByUUIDFunc == nil {
|
|
panic("Interface.DeviceGetHandleByUUIDFunc: method is nil but Interface.DeviceGetHandleByUUID was just called")
|
|
}
|
|
callInfo := struct {
|
|
S string
|
|
}{
|
|
S: s,
|
|
}
|
|
mock.lockDeviceGetHandleByUUID.Lock()
|
|
mock.calls.DeviceGetHandleByUUID = append(mock.calls.DeviceGetHandleByUUID, callInfo)
|
|
mock.lockDeviceGetHandleByUUID.Unlock()
|
|
return mock.DeviceGetHandleByUUIDFunc(s)
|
|
}
|
|
|
|
// DeviceGetHandleByUUIDCalls gets all the calls that were made to DeviceGetHandleByUUID.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetHandleByUUIDCalls())
|
|
func (mock *Interface) DeviceGetHandleByUUIDCalls() []struct {
|
|
S string
|
|
} {
|
|
var calls []struct {
|
|
S string
|
|
}
|
|
mock.lockDeviceGetHandleByUUID.RLock()
|
|
calls = mock.calls.DeviceGetHandleByUUID
|
|
mock.lockDeviceGetHandleByUUID.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetHostVgpuMode calls DeviceGetHostVgpuModeFunc.
|
|
func (mock *Interface) DeviceGetHostVgpuMode(device nvml.Device) (nvml.HostVgpuMode, nvml.Return) {
|
|
if mock.DeviceGetHostVgpuModeFunc == nil {
|
|
panic("Interface.DeviceGetHostVgpuModeFunc: method is nil but Interface.DeviceGetHostVgpuMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetHostVgpuMode.Lock()
|
|
mock.calls.DeviceGetHostVgpuMode = append(mock.calls.DeviceGetHostVgpuMode, callInfo)
|
|
mock.lockDeviceGetHostVgpuMode.Unlock()
|
|
return mock.DeviceGetHostVgpuModeFunc(device)
|
|
}
|
|
|
|
// DeviceGetHostVgpuModeCalls gets all the calls that were made to DeviceGetHostVgpuMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetHostVgpuModeCalls())
|
|
func (mock *Interface) DeviceGetHostVgpuModeCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetHostVgpuMode.RLock()
|
|
calls = mock.calls.DeviceGetHostVgpuMode
|
|
mock.lockDeviceGetHostVgpuMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetIndex calls DeviceGetIndexFunc.
|
|
func (mock *Interface) DeviceGetIndex(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetIndexFunc == nil {
|
|
panic("Interface.DeviceGetIndexFunc: method is nil but Interface.DeviceGetIndex was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetIndex.Lock()
|
|
mock.calls.DeviceGetIndex = append(mock.calls.DeviceGetIndex, callInfo)
|
|
mock.lockDeviceGetIndex.Unlock()
|
|
return mock.DeviceGetIndexFunc(device)
|
|
}
|
|
|
|
// DeviceGetIndexCalls gets all the calls that were made to DeviceGetIndex.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetIndexCalls())
|
|
func (mock *Interface) DeviceGetIndexCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetIndex.RLock()
|
|
calls = mock.calls.DeviceGetIndex
|
|
mock.lockDeviceGetIndex.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetInforomConfigurationChecksum calls DeviceGetInforomConfigurationChecksumFunc.
|
|
func (mock *Interface) DeviceGetInforomConfigurationChecksum(device nvml.Device) (uint32, nvml.Return) {
|
|
if mock.DeviceGetInforomConfigurationChecksumFunc == nil {
|
|
panic("Interface.DeviceGetInforomConfigurationChecksumFunc: method is nil but Interface.DeviceGetInforomConfigurationChecksum was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetInforomConfigurationChecksum.Lock()
|
|
mock.calls.DeviceGetInforomConfigurationChecksum = append(mock.calls.DeviceGetInforomConfigurationChecksum, callInfo)
|
|
mock.lockDeviceGetInforomConfigurationChecksum.Unlock()
|
|
return mock.DeviceGetInforomConfigurationChecksumFunc(device)
|
|
}
|
|
|
|
// DeviceGetInforomConfigurationChecksumCalls gets all the calls that were made to DeviceGetInforomConfigurationChecksum.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetInforomConfigurationChecksumCalls())
|
|
func (mock *Interface) DeviceGetInforomConfigurationChecksumCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetInforomConfigurationChecksum.RLock()
|
|
calls = mock.calls.DeviceGetInforomConfigurationChecksum
|
|
mock.lockDeviceGetInforomConfigurationChecksum.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetInforomImageVersion calls DeviceGetInforomImageVersionFunc.
|
|
func (mock *Interface) DeviceGetInforomImageVersion(device nvml.Device) (string, nvml.Return) {
|
|
if mock.DeviceGetInforomImageVersionFunc == nil {
|
|
panic("Interface.DeviceGetInforomImageVersionFunc: method is nil but Interface.DeviceGetInforomImageVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetInforomImageVersion.Lock()
|
|
mock.calls.DeviceGetInforomImageVersion = append(mock.calls.DeviceGetInforomImageVersion, callInfo)
|
|
mock.lockDeviceGetInforomImageVersion.Unlock()
|
|
return mock.DeviceGetInforomImageVersionFunc(device)
|
|
}
|
|
|
|
// DeviceGetInforomImageVersionCalls gets all the calls that were made to DeviceGetInforomImageVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetInforomImageVersionCalls())
|
|
func (mock *Interface) DeviceGetInforomImageVersionCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetInforomImageVersion.RLock()
|
|
calls = mock.calls.DeviceGetInforomImageVersion
|
|
mock.lockDeviceGetInforomImageVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetInforomVersion calls DeviceGetInforomVersionFunc.
|
|
func (mock *Interface) DeviceGetInforomVersion(device nvml.Device, inforomObject nvml.InforomObject) (string, nvml.Return) {
|
|
if mock.DeviceGetInforomVersionFunc == nil {
|
|
panic("Interface.DeviceGetInforomVersionFunc: method is nil but Interface.DeviceGetInforomVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
InforomObject nvml.InforomObject
|
|
}{
|
|
Device: device,
|
|
InforomObject: inforomObject,
|
|
}
|
|
mock.lockDeviceGetInforomVersion.Lock()
|
|
mock.calls.DeviceGetInforomVersion = append(mock.calls.DeviceGetInforomVersion, callInfo)
|
|
mock.lockDeviceGetInforomVersion.Unlock()
|
|
return mock.DeviceGetInforomVersionFunc(device, inforomObject)
|
|
}
|
|
|
|
// DeviceGetInforomVersionCalls gets all the calls that were made to DeviceGetInforomVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetInforomVersionCalls())
|
|
func (mock *Interface) DeviceGetInforomVersionCalls() []struct {
|
|
Device nvml.Device
|
|
InforomObject nvml.InforomObject
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
InforomObject nvml.InforomObject
|
|
}
|
|
mock.lockDeviceGetInforomVersion.RLock()
|
|
calls = mock.calls.DeviceGetInforomVersion
|
|
mock.lockDeviceGetInforomVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetIrqNum calls DeviceGetIrqNumFunc.
|
|
func (mock *Interface) DeviceGetIrqNum(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetIrqNumFunc == nil {
|
|
panic("Interface.DeviceGetIrqNumFunc: method is nil but Interface.DeviceGetIrqNum was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetIrqNum.Lock()
|
|
mock.calls.DeviceGetIrqNum = append(mock.calls.DeviceGetIrqNum, callInfo)
|
|
mock.lockDeviceGetIrqNum.Unlock()
|
|
return mock.DeviceGetIrqNumFunc(device)
|
|
}
|
|
|
|
// DeviceGetIrqNumCalls gets all the calls that were made to DeviceGetIrqNum.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetIrqNumCalls())
|
|
func (mock *Interface) DeviceGetIrqNumCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetIrqNum.RLock()
|
|
calls = mock.calls.DeviceGetIrqNum
|
|
mock.lockDeviceGetIrqNum.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMPSComputeRunningProcesses calls DeviceGetMPSComputeRunningProcessesFunc.
|
|
func (mock *Interface) DeviceGetMPSComputeRunningProcesses(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return) {
|
|
if mock.DeviceGetMPSComputeRunningProcessesFunc == nil {
|
|
panic("Interface.DeviceGetMPSComputeRunningProcessesFunc: method is nil but Interface.DeviceGetMPSComputeRunningProcesses was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetMPSComputeRunningProcesses.Lock()
|
|
mock.calls.DeviceGetMPSComputeRunningProcesses = append(mock.calls.DeviceGetMPSComputeRunningProcesses, callInfo)
|
|
mock.lockDeviceGetMPSComputeRunningProcesses.Unlock()
|
|
return mock.DeviceGetMPSComputeRunningProcessesFunc(device)
|
|
}
|
|
|
|
// DeviceGetMPSComputeRunningProcessesCalls gets all the calls that were made to DeviceGetMPSComputeRunningProcesses.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMPSComputeRunningProcessesCalls())
|
|
func (mock *Interface) DeviceGetMPSComputeRunningProcessesCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetMPSComputeRunningProcesses.RLock()
|
|
calls = mock.calls.DeviceGetMPSComputeRunningProcesses
|
|
mock.lockDeviceGetMPSComputeRunningProcesses.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMaxClockInfo calls DeviceGetMaxClockInfoFunc.
|
|
func (mock *Interface) DeviceGetMaxClockInfo(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
if mock.DeviceGetMaxClockInfoFunc == nil {
|
|
panic("Interface.DeviceGetMaxClockInfoFunc: method is nil but Interface.DeviceGetMaxClockInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
}{
|
|
Device: device,
|
|
ClockType: clockType,
|
|
}
|
|
mock.lockDeviceGetMaxClockInfo.Lock()
|
|
mock.calls.DeviceGetMaxClockInfo = append(mock.calls.DeviceGetMaxClockInfo, callInfo)
|
|
mock.lockDeviceGetMaxClockInfo.Unlock()
|
|
return mock.DeviceGetMaxClockInfoFunc(device, clockType)
|
|
}
|
|
|
|
// DeviceGetMaxClockInfoCalls gets all the calls that were made to DeviceGetMaxClockInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMaxClockInfoCalls())
|
|
func (mock *Interface) DeviceGetMaxClockInfoCalls() []struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
}
|
|
mock.lockDeviceGetMaxClockInfo.RLock()
|
|
calls = mock.calls.DeviceGetMaxClockInfo
|
|
mock.lockDeviceGetMaxClockInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMaxCustomerBoostClock calls DeviceGetMaxCustomerBoostClockFunc.
|
|
func (mock *Interface) DeviceGetMaxCustomerBoostClock(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
if mock.DeviceGetMaxCustomerBoostClockFunc == nil {
|
|
panic("Interface.DeviceGetMaxCustomerBoostClockFunc: method is nil but Interface.DeviceGetMaxCustomerBoostClock was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
}{
|
|
Device: device,
|
|
ClockType: clockType,
|
|
}
|
|
mock.lockDeviceGetMaxCustomerBoostClock.Lock()
|
|
mock.calls.DeviceGetMaxCustomerBoostClock = append(mock.calls.DeviceGetMaxCustomerBoostClock, callInfo)
|
|
mock.lockDeviceGetMaxCustomerBoostClock.Unlock()
|
|
return mock.DeviceGetMaxCustomerBoostClockFunc(device, clockType)
|
|
}
|
|
|
|
// DeviceGetMaxCustomerBoostClockCalls gets all the calls that were made to DeviceGetMaxCustomerBoostClock.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMaxCustomerBoostClockCalls())
|
|
func (mock *Interface) DeviceGetMaxCustomerBoostClockCalls() []struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
}
|
|
mock.lockDeviceGetMaxCustomerBoostClock.RLock()
|
|
calls = mock.calls.DeviceGetMaxCustomerBoostClock
|
|
mock.lockDeviceGetMaxCustomerBoostClock.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMaxMigDeviceCount calls DeviceGetMaxMigDeviceCountFunc.
|
|
func (mock *Interface) DeviceGetMaxMigDeviceCount(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetMaxMigDeviceCountFunc == nil {
|
|
panic("Interface.DeviceGetMaxMigDeviceCountFunc: method is nil but Interface.DeviceGetMaxMigDeviceCount was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetMaxMigDeviceCount.Lock()
|
|
mock.calls.DeviceGetMaxMigDeviceCount = append(mock.calls.DeviceGetMaxMigDeviceCount, callInfo)
|
|
mock.lockDeviceGetMaxMigDeviceCount.Unlock()
|
|
return mock.DeviceGetMaxMigDeviceCountFunc(device)
|
|
}
|
|
|
|
// DeviceGetMaxMigDeviceCountCalls gets all the calls that were made to DeviceGetMaxMigDeviceCount.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMaxMigDeviceCountCalls())
|
|
func (mock *Interface) DeviceGetMaxMigDeviceCountCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetMaxMigDeviceCount.RLock()
|
|
calls = mock.calls.DeviceGetMaxMigDeviceCount
|
|
mock.lockDeviceGetMaxMigDeviceCount.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMaxPcieLinkGeneration calls DeviceGetMaxPcieLinkGenerationFunc.
|
|
func (mock *Interface) DeviceGetMaxPcieLinkGeneration(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetMaxPcieLinkGenerationFunc == nil {
|
|
panic("Interface.DeviceGetMaxPcieLinkGenerationFunc: method is nil but Interface.DeviceGetMaxPcieLinkGeneration was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetMaxPcieLinkGeneration.Lock()
|
|
mock.calls.DeviceGetMaxPcieLinkGeneration = append(mock.calls.DeviceGetMaxPcieLinkGeneration, callInfo)
|
|
mock.lockDeviceGetMaxPcieLinkGeneration.Unlock()
|
|
return mock.DeviceGetMaxPcieLinkGenerationFunc(device)
|
|
}
|
|
|
|
// DeviceGetMaxPcieLinkGenerationCalls gets all the calls that were made to DeviceGetMaxPcieLinkGeneration.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMaxPcieLinkGenerationCalls())
|
|
func (mock *Interface) DeviceGetMaxPcieLinkGenerationCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetMaxPcieLinkGeneration.RLock()
|
|
calls = mock.calls.DeviceGetMaxPcieLinkGeneration
|
|
mock.lockDeviceGetMaxPcieLinkGeneration.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMaxPcieLinkWidth calls DeviceGetMaxPcieLinkWidthFunc.
|
|
func (mock *Interface) DeviceGetMaxPcieLinkWidth(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetMaxPcieLinkWidthFunc == nil {
|
|
panic("Interface.DeviceGetMaxPcieLinkWidthFunc: method is nil but Interface.DeviceGetMaxPcieLinkWidth was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetMaxPcieLinkWidth.Lock()
|
|
mock.calls.DeviceGetMaxPcieLinkWidth = append(mock.calls.DeviceGetMaxPcieLinkWidth, callInfo)
|
|
mock.lockDeviceGetMaxPcieLinkWidth.Unlock()
|
|
return mock.DeviceGetMaxPcieLinkWidthFunc(device)
|
|
}
|
|
|
|
// DeviceGetMaxPcieLinkWidthCalls gets all the calls that were made to DeviceGetMaxPcieLinkWidth.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMaxPcieLinkWidthCalls())
|
|
func (mock *Interface) DeviceGetMaxPcieLinkWidthCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetMaxPcieLinkWidth.RLock()
|
|
calls = mock.calls.DeviceGetMaxPcieLinkWidth
|
|
mock.lockDeviceGetMaxPcieLinkWidth.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMemClkMinMaxVfOffset calls DeviceGetMemClkMinMaxVfOffsetFunc.
|
|
func (mock *Interface) DeviceGetMemClkMinMaxVfOffset(device nvml.Device) (int, int, nvml.Return) {
|
|
if mock.DeviceGetMemClkMinMaxVfOffsetFunc == nil {
|
|
panic("Interface.DeviceGetMemClkMinMaxVfOffsetFunc: method is nil but Interface.DeviceGetMemClkMinMaxVfOffset was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetMemClkMinMaxVfOffset.Lock()
|
|
mock.calls.DeviceGetMemClkMinMaxVfOffset = append(mock.calls.DeviceGetMemClkMinMaxVfOffset, callInfo)
|
|
mock.lockDeviceGetMemClkMinMaxVfOffset.Unlock()
|
|
return mock.DeviceGetMemClkMinMaxVfOffsetFunc(device)
|
|
}
|
|
|
|
// DeviceGetMemClkMinMaxVfOffsetCalls gets all the calls that were made to DeviceGetMemClkMinMaxVfOffset.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMemClkMinMaxVfOffsetCalls())
|
|
func (mock *Interface) DeviceGetMemClkMinMaxVfOffsetCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetMemClkMinMaxVfOffset.RLock()
|
|
calls = mock.calls.DeviceGetMemClkMinMaxVfOffset
|
|
mock.lockDeviceGetMemClkMinMaxVfOffset.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMemClkVfOffset calls DeviceGetMemClkVfOffsetFunc.
|
|
func (mock *Interface) DeviceGetMemClkVfOffset(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetMemClkVfOffsetFunc == nil {
|
|
panic("Interface.DeviceGetMemClkVfOffsetFunc: method is nil but Interface.DeviceGetMemClkVfOffset was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetMemClkVfOffset.Lock()
|
|
mock.calls.DeviceGetMemClkVfOffset = append(mock.calls.DeviceGetMemClkVfOffset, callInfo)
|
|
mock.lockDeviceGetMemClkVfOffset.Unlock()
|
|
return mock.DeviceGetMemClkVfOffsetFunc(device)
|
|
}
|
|
|
|
// DeviceGetMemClkVfOffsetCalls gets all the calls that were made to DeviceGetMemClkVfOffset.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMemClkVfOffsetCalls())
|
|
func (mock *Interface) DeviceGetMemClkVfOffsetCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetMemClkVfOffset.RLock()
|
|
calls = mock.calls.DeviceGetMemClkVfOffset
|
|
mock.lockDeviceGetMemClkVfOffset.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMemoryAffinity calls DeviceGetMemoryAffinityFunc.
|
|
func (mock *Interface) DeviceGetMemoryAffinity(device nvml.Device, n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return) {
|
|
if mock.DeviceGetMemoryAffinityFunc == nil {
|
|
panic("Interface.DeviceGetMemoryAffinityFunc: method is nil but Interface.DeviceGetMemoryAffinity was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
AffinityScope nvml.AffinityScope
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
AffinityScope: affinityScope,
|
|
}
|
|
mock.lockDeviceGetMemoryAffinity.Lock()
|
|
mock.calls.DeviceGetMemoryAffinity = append(mock.calls.DeviceGetMemoryAffinity, callInfo)
|
|
mock.lockDeviceGetMemoryAffinity.Unlock()
|
|
return mock.DeviceGetMemoryAffinityFunc(device, n, affinityScope)
|
|
}
|
|
|
|
// DeviceGetMemoryAffinityCalls gets all the calls that were made to DeviceGetMemoryAffinity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMemoryAffinityCalls())
|
|
func (mock *Interface) DeviceGetMemoryAffinityCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
AffinityScope nvml.AffinityScope
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
AffinityScope nvml.AffinityScope
|
|
}
|
|
mock.lockDeviceGetMemoryAffinity.RLock()
|
|
calls = mock.calls.DeviceGetMemoryAffinity
|
|
mock.lockDeviceGetMemoryAffinity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMemoryBusWidth calls DeviceGetMemoryBusWidthFunc.
|
|
func (mock *Interface) DeviceGetMemoryBusWidth(device nvml.Device) (uint32, nvml.Return) {
|
|
if mock.DeviceGetMemoryBusWidthFunc == nil {
|
|
panic("Interface.DeviceGetMemoryBusWidthFunc: method is nil but Interface.DeviceGetMemoryBusWidth was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetMemoryBusWidth.Lock()
|
|
mock.calls.DeviceGetMemoryBusWidth = append(mock.calls.DeviceGetMemoryBusWidth, callInfo)
|
|
mock.lockDeviceGetMemoryBusWidth.Unlock()
|
|
return mock.DeviceGetMemoryBusWidthFunc(device)
|
|
}
|
|
|
|
// DeviceGetMemoryBusWidthCalls gets all the calls that were made to DeviceGetMemoryBusWidth.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMemoryBusWidthCalls())
|
|
func (mock *Interface) DeviceGetMemoryBusWidthCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetMemoryBusWidth.RLock()
|
|
calls = mock.calls.DeviceGetMemoryBusWidth
|
|
mock.lockDeviceGetMemoryBusWidth.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMemoryErrorCounter calls DeviceGetMemoryErrorCounterFunc.
|
|
func (mock *Interface) DeviceGetMemoryErrorCounter(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType, memoryLocation nvml.MemoryLocation) (uint64, nvml.Return) {
|
|
if mock.DeviceGetMemoryErrorCounterFunc == nil {
|
|
panic("Interface.DeviceGetMemoryErrorCounterFunc: method is nil but Interface.DeviceGetMemoryErrorCounter was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
MemoryLocation nvml.MemoryLocation
|
|
}{
|
|
Device: device,
|
|
MemoryErrorType: memoryErrorType,
|
|
EccCounterType: eccCounterType,
|
|
MemoryLocation: memoryLocation,
|
|
}
|
|
mock.lockDeviceGetMemoryErrorCounter.Lock()
|
|
mock.calls.DeviceGetMemoryErrorCounter = append(mock.calls.DeviceGetMemoryErrorCounter, callInfo)
|
|
mock.lockDeviceGetMemoryErrorCounter.Unlock()
|
|
return mock.DeviceGetMemoryErrorCounterFunc(device, memoryErrorType, eccCounterType, memoryLocation)
|
|
}
|
|
|
|
// DeviceGetMemoryErrorCounterCalls gets all the calls that were made to DeviceGetMemoryErrorCounter.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMemoryErrorCounterCalls())
|
|
func (mock *Interface) DeviceGetMemoryErrorCounterCalls() []struct {
|
|
Device nvml.Device
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
MemoryLocation nvml.MemoryLocation
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
MemoryLocation nvml.MemoryLocation
|
|
}
|
|
mock.lockDeviceGetMemoryErrorCounter.RLock()
|
|
calls = mock.calls.DeviceGetMemoryErrorCounter
|
|
mock.lockDeviceGetMemoryErrorCounter.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMemoryInfo calls DeviceGetMemoryInfoFunc.
|
|
func (mock *Interface) DeviceGetMemoryInfo(device nvml.Device) (nvml.Memory, nvml.Return) {
|
|
if mock.DeviceGetMemoryInfoFunc == nil {
|
|
panic("Interface.DeviceGetMemoryInfoFunc: method is nil but Interface.DeviceGetMemoryInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetMemoryInfo.Lock()
|
|
mock.calls.DeviceGetMemoryInfo = append(mock.calls.DeviceGetMemoryInfo, callInfo)
|
|
mock.lockDeviceGetMemoryInfo.Unlock()
|
|
return mock.DeviceGetMemoryInfoFunc(device)
|
|
}
|
|
|
|
// DeviceGetMemoryInfoCalls gets all the calls that were made to DeviceGetMemoryInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMemoryInfoCalls())
|
|
func (mock *Interface) DeviceGetMemoryInfoCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetMemoryInfo.RLock()
|
|
calls = mock.calls.DeviceGetMemoryInfo
|
|
mock.lockDeviceGetMemoryInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMemoryInfo_v2 calls DeviceGetMemoryInfo_v2Func.
|
|
func (mock *Interface) DeviceGetMemoryInfo_v2(device nvml.Device) (nvml.Memory_v2, nvml.Return) {
|
|
if mock.DeviceGetMemoryInfo_v2Func == nil {
|
|
panic("Interface.DeviceGetMemoryInfo_v2Func: method is nil but Interface.DeviceGetMemoryInfo_v2 was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetMemoryInfo_v2.Lock()
|
|
mock.calls.DeviceGetMemoryInfo_v2 = append(mock.calls.DeviceGetMemoryInfo_v2, callInfo)
|
|
mock.lockDeviceGetMemoryInfo_v2.Unlock()
|
|
return mock.DeviceGetMemoryInfo_v2Func(device)
|
|
}
|
|
|
|
// DeviceGetMemoryInfo_v2Calls gets all the calls that were made to DeviceGetMemoryInfo_v2.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMemoryInfo_v2Calls())
|
|
func (mock *Interface) DeviceGetMemoryInfo_v2Calls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetMemoryInfo_v2.RLock()
|
|
calls = mock.calls.DeviceGetMemoryInfo_v2
|
|
mock.lockDeviceGetMemoryInfo_v2.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMigDeviceHandleByIndex calls DeviceGetMigDeviceHandleByIndexFunc.
|
|
func (mock *Interface) DeviceGetMigDeviceHandleByIndex(device nvml.Device, n int) (nvml.Device, nvml.Return) {
|
|
if mock.DeviceGetMigDeviceHandleByIndexFunc == nil {
|
|
panic("Interface.DeviceGetMigDeviceHandleByIndexFunc: method is nil but Interface.DeviceGetMigDeviceHandleByIndex was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceGetMigDeviceHandleByIndex.Lock()
|
|
mock.calls.DeviceGetMigDeviceHandleByIndex = append(mock.calls.DeviceGetMigDeviceHandleByIndex, callInfo)
|
|
mock.lockDeviceGetMigDeviceHandleByIndex.Unlock()
|
|
return mock.DeviceGetMigDeviceHandleByIndexFunc(device, n)
|
|
}
|
|
|
|
// DeviceGetMigDeviceHandleByIndexCalls gets all the calls that were made to DeviceGetMigDeviceHandleByIndex.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMigDeviceHandleByIndexCalls())
|
|
func (mock *Interface) DeviceGetMigDeviceHandleByIndexCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceGetMigDeviceHandleByIndex.RLock()
|
|
calls = mock.calls.DeviceGetMigDeviceHandleByIndex
|
|
mock.lockDeviceGetMigDeviceHandleByIndex.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMigMode calls DeviceGetMigModeFunc.
|
|
func (mock *Interface) DeviceGetMigMode(device nvml.Device) (int, int, nvml.Return) {
|
|
if mock.DeviceGetMigModeFunc == nil {
|
|
panic("Interface.DeviceGetMigModeFunc: method is nil but Interface.DeviceGetMigMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetMigMode.Lock()
|
|
mock.calls.DeviceGetMigMode = append(mock.calls.DeviceGetMigMode, callInfo)
|
|
mock.lockDeviceGetMigMode.Unlock()
|
|
return mock.DeviceGetMigModeFunc(device)
|
|
}
|
|
|
|
// DeviceGetMigModeCalls gets all the calls that were made to DeviceGetMigMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMigModeCalls())
|
|
func (mock *Interface) DeviceGetMigModeCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetMigMode.RLock()
|
|
calls = mock.calls.DeviceGetMigMode
|
|
mock.lockDeviceGetMigMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMinMaxClockOfPState calls DeviceGetMinMaxClockOfPStateFunc.
|
|
func (mock *Interface) DeviceGetMinMaxClockOfPState(device nvml.Device, clockType nvml.ClockType, pstates nvml.Pstates) (uint32, uint32, nvml.Return) {
|
|
if mock.DeviceGetMinMaxClockOfPStateFunc == nil {
|
|
panic("Interface.DeviceGetMinMaxClockOfPStateFunc: method is nil but Interface.DeviceGetMinMaxClockOfPState was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
Pstates nvml.Pstates
|
|
}{
|
|
Device: device,
|
|
ClockType: clockType,
|
|
Pstates: pstates,
|
|
}
|
|
mock.lockDeviceGetMinMaxClockOfPState.Lock()
|
|
mock.calls.DeviceGetMinMaxClockOfPState = append(mock.calls.DeviceGetMinMaxClockOfPState, callInfo)
|
|
mock.lockDeviceGetMinMaxClockOfPState.Unlock()
|
|
return mock.DeviceGetMinMaxClockOfPStateFunc(device, clockType, pstates)
|
|
}
|
|
|
|
// DeviceGetMinMaxClockOfPStateCalls gets all the calls that were made to DeviceGetMinMaxClockOfPState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMinMaxClockOfPStateCalls())
|
|
func (mock *Interface) DeviceGetMinMaxClockOfPStateCalls() []struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
Pstates nvml.Pstates
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
ClockType nvml.ClockType
|
|
Pstates nvml.Pstates
|
|
}
|
|
mock.lockDeviceGetMinMaxClockOfPState.RLock()
|
|
calls = mock.calls.DeviceGetMinMaxClockOfPState
|
|
mock.lockDeviceGetMinMaxClockOfPState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMinMaxFanSpeed calls DeviceGetMinMaxFanSpeedFunc.
|
|
func (mock *Interface) DeviceGetMinMaxFanSpeed(device nvml.Device) (int, int, nvml.Return) {
|
|
if mock.DeviceGetMinMaxFanSpeedFunc == nil {
|
|
panic("Interface.DeviceGetMinMaxFanSpeedFunc: method is nil but Interface.DeviceGetMinMaxFanSpeed was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetMinMaxFanSpeed.Lock()
|
|
mock.calls.DeviceGetMinMaxFanSpeed = append(mock.calls.DeviceGetMinMaxFanSpeed, callInfo)
|
|
mock.lockDeviceGetMinMaxFanSpeed.Unlock()
|
|
return mock.DeviceGetMinMaxFanSpeedFunc(device)
|
|
}
|
|
|
|
// DeviceGetMinMaxFanSpeedCalls gets all the calls that were made to DeviceGetMinMaxFanSpeed.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMinMaxFanSpeedCalls())
|
|
func (mock *Interface) DeviceGetMinMaxFanSpeedCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetMinMaxFanSpeed.RLock()
|
|
calls = mock.calls.DeviceGetMinMaxFanSpeed
|
|
mock.lockDeviceGetMinMaxFanSpeed.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMinorNumber calls DeviceGetMinorNumberFunc.
|
|
func (mock *Interface) DeviceGetMinorNumber(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetMinorNumberFunc == nil {
|
|
panic("Interface.DeviceGetMinorNumberFunc: method is nil but Interface.DeviceGetMinorNumber was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetMinorNumber.Lock()
|
|
mock.calls.DeviceGetMinorNumber = append(mock.calls.DeviceGetMinorNumber, callInfo)
|
|
mock.lockDeviceGetMinorNumber.Unlock()
|
|
return mock.DeviceGetMinorNumberFunc(device)
|
|
}
|
|
|
|
// DeviceGetMinorNumberCalls gets all the calls that were made to DeviceGetMinorNumber.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMinorNumberCalls())
|
|
func (mock *Interface) DeviceGetMinorNumberCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetMinorNumber.RLock()
|
|
calls = mock.calls.DeviceGetMinorNumber
|
|
mock.lockDeviceGetMinorNumber.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetMultiGpuBoard calls DeviceGetMultiGpuBoardFunc.
|
|
func (mock *Interface) DeviceGetMultiGpuBoard(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetMultiGpuBoardFunc == nil {
|
|
panic("Interface.DeviceGetMultiGpuBoardFunc: method is nil but Interface.DeviceGetMultiGpuBoard was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetMultiGpuBoard.Lock()
|
|
mock.calls.DeviceGetMultiGpuBoard = append(mock.calls.DeviceGetMultiGpuBoard, callInfo)
|
|
mock.lockDeviceGetMultiGpuBoard.Unlock()
|
|
return mock.DeviceGetMultiGpuBoardFunc(device)
|
|
}
|
|
|
|
// DeviceGetMultiGpuBoardCalls gets all the calls that were made to DeviceGetMultiGpuBoard.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetMultiGpuBoardCalls())
|
|
func (mock *Interface) DeviceGetMultiGpuBoardCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetMultiGpuBoard.RLock()
|
|
calls = mock.calls.DeviceGetMultiGpuBoard
|
|
mock.lockDeviceGetMultiGpuBoard.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetName calls DeviceGetNameFunc.
|
|
func (mock *Interface) DeviceGetName(device nvml.Device) (string, nvml.Return) {
|
|
if mock.DeviceGetNameFunc == nil {
|
|
panic("Interface.DeviceGetNameFunc: method is nil but Interface.DeviceGetName was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetName.Lock()
|
|
mock.calls.DeviceGetName = append(mock.calls.DeviceGetName, callInfo)
|
|
mock.lockDeviceGetName.Unlock()
|
|
return mock.DeviceGetNameFunc(device)
|
|
}
|
|
|
|
// DeviceGetNameCalls gets all the calls that were made to DeviceGetName.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetNameCalls())
|
|
func (mock *Interface) DeviceGetNameCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetName.RLock()
|
|
calls = mock.calls.DeviceGetName
|
|
mock.lockDeviceGetName.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetNumFans calls DeviceGetNumFansFunc.
|
|
func (mock *Interface) DeviceGetNumFans(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetNumFansFunc == nil {
|
|
panic("Interface.DeviceGetNumFansFunc: method is nil but Interface.DeviceGetNumFans was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetNumFans.Lock()
|
|
mock.calls.DeviceGetNumFans = append(mock.calls.DeviceGetNumFans, callInfo)
|
|
mock.lockDeviceGetNumFans.Unlock()
|
|
return mock.DeviceGetNumFansFunc(device)
|
|
}
|
|
|
|
// DeviceGetNumFansCalls gets all the calls that were made to DeviceGetNumFans.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetNumFansCalls())
|
|
func (mock *Interface) DeviceGetNumFansCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetNumFans.RLock()
|
|
calls = mock.calls.DeviceGetNumFans
|
|
mock.lockDeviceGetNumFans.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetNumGpuCores calls DeviceGetNumGpuCoresFunc.
|
|
func (mock *Interface) DeviceGetNumGpuCores(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetNumGpuCoresFunc == nil {
|
|
panic("Interface.DeviceGetNumGpuCoresFunc: method is nil but Interface.DeviceGetNumGpuCores was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetNumGpuCores.Lock()
|
|
mock.calls.DeviceGetNumGpuCores = append(mock.calls.DeviceGetNumGpuCores, callInfo)
|
|
mock.lockDeviceGetNumGpuCores.Unlock()
|
|
return mock.DeviceGetNumGpuCoresFunc(device)
|
|
}
|
|
|
|
// DeviceGetNumGpuCoresCalls gets all the calls that were made to DeviceGetNumGpuCores.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetNumGpuCoresCalls())
|
|
func (mock *Interface) DeviceGetNumGpuCoresCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetNumGpuCores.RLock()
|
|
calls = mock.calls.DeviceGetNumGpuCores
|
|
mock.lockDeviceGetNumGpuCores.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetNvLinkCapability calls DeviceGetNvLinkCapabilityFunc.
|
|
func (mock *Interface) DeviceGetNvLinkCapability(device nvml.Device, n int, nvLinkCapability nvml.NvLinkCapability) (uint32, nvml.Return) {
|
|
if mock.DeviceGetNvLinkCapabilityFunc == nil {
|
|
panic("Interface.DeviceGetNvLinkCapabilityFunc: method is nil but Interface.DeviceGetNvLinkCapability was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
NvLinkCapability nvml.NvLinkCapability
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
NvLinkCapability: nvLinkCapability,
|
|
}
|
|
mock.lockDeviceGetNvLinkCapability.Lock()
|
|
mock.calls.DeviceGetNvLinkCapability = append(mock.calls.DeviceGetNvLinkCapability, callInfo)
|
|
mock.lockDeviceGetNvLinkCapability.Unlock()
|
|
return mock.DeviceGetNvLinkCapabilityFunc(device, n, nvLinkCapability)
|
|
}
|
|
|
|
// DeviceGetNvLinkCapabilityCalls gets all the calls that were made to DeviceGetNvLinkCapability.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetNvLinkCapabilityCalls())
|
|
func (mock *Interface) DeviceGetNvLinkCapabilityCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
NvLinkCapability nvml.NvLinkCapability
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
NvLinkCapability nvml.NvLinkCapability
|
|
}
|
|
mock.lockDeviceGetNvLinkCapability.RLock()
|
|
calls = mock.calls.DeviceGetNvLinkCapability
|
|
mock.lockDeviceGetNvLinkCapability.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetNvLinkErrorCounter calls DeviceGetNvLinkErrorCounterFunc.
|
|
func (mock *Interface) DeviceGetNvLinkErrorCounter(device nvml.Device, n int, nvLinkErrorCounter nvml.NvLinkErrorCounter) (uint64, nvml.Return) {
|
|
if mock.DeviceGetNvLinkErrorCounterFunc == nil {
|
|
panic("Interface.DeviceGetNvLinkErrorCounterFunc: method is nil but Interface.DeviceGetNvLinkErrorCounter was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
NvLinkErrorCounter nvml.NvLinkErrorCounter
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
NvLinkErrorCounter: nvLinkErrorCounter,
|
|
}
|
|
mock.lockDeviceGetNvLinkErrorCounter.Lock()
|
|
mock.calls.DeviceGetNvLinkErrorCounter = append(mock.calls.DeviceGetNvLinkErrorCounter, callInfo)
|
|
mock.lockDeviceGetNvLinkErrorCounter.Unlock()
|
|
return mock.DeviceGetNvLinkErrorCounterFunc(device, n, nvLinkErrorCounter)
|
|
}
|
|
|
|
// DeviceGetNvLinkErrorCounterCalls gets all the calls that were made to DeviceGetNvLinkErrorCounter.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetNvLinkErrorCounterCalls())
|
|
func (mock *Interface) DeviceGetNvLinkErrorCounterCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
NvLinkErrorCounter nvml.NvLinkErrorCounter
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
NvLinkErrorCounter nvml.NvLinkErrorCounter
|
|
}
|
|
mock.lockDeviceGetNvLinkErrorCounter.RLock()
|
|
calls = mock.calls.DeviceGetNvLinkErrorCounter
|
|
mock.lockDeviceGetNvLinkErrorCounter.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetNvLinkRemoteDeviceType calls DeviceGetNvLinkRemoteDeviceTypeFunc.
|
|
func (mock *Interface) DeviceGetNvLinkRemoteDeviceType(device nvml.Device, n int) (nvml.IntNvLinkDeviceType, nvml.Return) {
|
|
if mock.DeviceGetNvLinkRemoteDeviceTypeFunc == nil {
|
|
panic("Interface.DeviceGetNvLinkRemoteDeviceTypeFunc: method is nil but Interface.DeviceGetNvLinkRemoteDeviceType was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceGetNvLinkRemoteDeviceType.Lock()
|
|
mock.calls.DeviceGetNvLinkRemoteDeviceType = append(mock.calls.DeviceGetNvLinkRemoteDeviceType, callInfo)
|
|
mock.lockDeviceGetNvLinkRemoteDeviceType.Unlock()
|
|
return mock.DeviceGetNvLinkRemoteDeviceTypeFunc(device, n)
|
|
}
|
|
|
|
// DeviceGetNvLinkRemoteDeviceTypeCalls gets all the calls that were made to DeviceGetNvLinkRemoteDeviceType.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetNvLinkRemoteDeviceTypeCalls())
|
|
func (mock *Interface) DeviceGetNvLinkRemoteDeviceTypeCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceGetNvLinkRemoteDeviceType.RLock()
|
|
calls = mock.calls.DeviceGetNvLinkRemoteDeviceType
|
|
mock.lockDeviceGetNvLinkRemoteDeviceType.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetNvLinkRemotePciInfo calls DeviceGetNvLinkRemotePciInfoFunc.
|
|
func (mock *Interface) DeviceGetNvLinkRemotePciInfo(device nvml.Device, n int) (nvml.PciInfo, nvml.Return) {
|
|
if mock.DeviceGetNvLinkRemotePciInfoFunc == nil {
|
|
panic("Interface.DeviceGetNvLinkRemotePciInfoFunc: method is nil but Interface.DeviceGetNvLinkRemotePciInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceGetNvLinkRemotePciInfo.Lock()
|
|
mock.calls.DeviceGetNvLinkRemotePciInfo = append(mock.calls.DeviceGetNvLinkRemotePciInfo, callInfo)
|
|
mock.lockDeviceGetNvLinkRemotePciInfo.Unlock()
|
|
return mock.DeviceGetNvLinkRemotePciInfoFunc(device, n)
|
|
}
|
|
|
|
// DeviceGetNvLinkRemotePciInfoCalls gets all the calls that were made to DeviceGetNvLinkRemotePciInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetNvLinkRemotePciInfoCalls())
|
|
func (mock *Interface) DeviceGetNvLinkRemotePciInfoCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceGetNvLinkRemotePciInfo.RLock()
|
|
calls = mock.calls.DeviceGetNvLinkRemotePciInfo
|
|
mock.lockDeviceGetNvLinkRemotePciInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetNvLinkState calls DeviceGetNvLinkStateFunc.
|
|
func (mock *Interface) DeviceGetNvLinkState(device nvml.Device, n int) (nvml.EnableState, nvml.Return) {
|
|
if mock.DeviceGetNvLinkStateFunc == nil {
|
|
panic("Interface.DeviceGetNvLinkStateFunc: method is nil but Interface.DeviceGetNvLinkState was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceGetNvLinkState.Lock()
|
|
mock.calls.DeviceGetNvLinkState = append(mock.calls.DeviceGetNvLinkState, callInfo)
|
|
mock.lockDeviceGetNvLinkState.Unlock()
|
|
return mock.DeviceGetNvLinkStateFunc(device, n)
|
|
}
|
|
|
|
// DeviceGetNvLinkStateCalls gets all the calls that were made to DeviceGetNvLinkState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetNvLinkStateCalls())
|
|
func (mock *Interface) DeviceGetNvLinkStateCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceGetNvLinkState.RLock()
|
|
calls = mock.calls.DeviceGetNvLinkState
|
|
mock.lockDeviceGetNvLinkState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetNvLinkUtilizationControl calls DeviceGetNvLinkUtilizationControlFunc.
|
|
func (mock *Interface) DeviceGetNvLinkUtilizationControl(device nvml.Device, n1 int, n2 int) (nvml.NvLinkUtilizationControl, nvml.Return) {
|
|
if mock.DeviceGetNvLinkUtilizationControlFunc == nil {
|
|
panic("Interface.DeviceGetNvLinkUtilizationControlFunc: method is nil but Interface.DeviceGetNvLinkUtilizationControl was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
}{
|
|
Device: device,
|
|
N1: n1,
|
|
N2: n2,
|
|
}
|
|
mock.lockDeviceGetNvLinkUtilizationControl.Lock()
|
|
mock.calls.DeviceGetNvLinkUtilizationControl = append(mock.calls.DeviceGetNvLinkUtilizationControl, callInfo)
|
|
mock.lockDeviceGetNvLinkUtilizationControl.Unlock()
|
|
return mock.DeviceGetNvLinkUtilizationControlFunc(device, n1, n2)
|
|
}
|
|
|
|
// DeviceGetNvLinkUtilizationControlCalls gets all the calls that were made to DeviceGetNvLinkUtilizationControl.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetNvLinkUtilizationControlCalls())
|
|
func (mock *Interface) DeviceGetNvLinkUtilizationControlCalls() []struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
}
|
|
mock.lockDeviceGetNvLinkUtilizationControl.RLock()
|
|
calls = mock.calls.DeviceGetNvLinkUtilizationControl
|
|
mock.lockDeviceGetNvLinkUtilizationControl.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetNvLinkUtilizationCounter calls DeviceGetNvLinkUtilizationCounterFunc.
|
|
func (mock *Interface) DeviceGetNvLinkUtilizationCounter(device nvml.Device, n1 int, n2 int) (uint64, uint64, nvml.Return) {
|
|
if mock.DeviceGetNvLinkUtilizationCounterFunc == nil {
|
|
panic("Interface.DeviceGetNvLinkUtilizationCounterFunc: method is nil but Interface.DeviceGetNvLinkUtilizationCounter was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
}{
|
|
Device: device,
|
|
N1: n1,
|
|
N2: n2,
|
|
}
|
|
mock.lockDeviceGetNvLinkUtilizationCounter.Lock()
|
|
mock.calls.DeviceGetNvLinkUtilizationCounter = append(mock.calls.DeviceGetNvLinkUtilizationCounter, callInfo)
|
|
mock.lockDeviceGetNvLinkUtilizationCounter.Unlock()
|
|
return mock.DeviceGetNvLinkUtilizationCounterFunc(device, n1, n2)
|
|
}
|
|
|
|
// DeviceGetNvLinkUtilizationCounterCalls gets all the calls that were made to DeviceGetNvLinkUtilizationCounter.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetNvLinkUtilizationCounterCalls())
|
|
func (mock *Interface) DeviceGetNvLinkUtilizationCounterCalls() []struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
}
|
|
mock.lockDeviceGetNvLinkUtilizationCounter.RLock()
|
|
calls = mock.calls.DeviceGetNvLinkUtilizationCounter
|
|
mock.lockDeviceGetNvLinkUtilizationCounter.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetNvLinkVersion calls DeviceGetNvLinkVersionFunc.
|
|
func (mock *Interface) DeviceGetNvLinkVersion(device nvml.Device, n int) (uint32, nvml.Return) {
|
|
if mock.DeviceGetNvLinkVersionFunc == nil {
|
|
panic("Interface.DeviceGetNvLinkVersionFunc: method is nil but Interface.DeviceGetNvLinkVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceGetNvLinkVersion.Lock()
|
|
mock.calls.DeviceGetNvLinkVersion = append(mock.calls.DeviceGetNvLinkVersion, callInfo)
|
|
mock.lockDeviceGetNvLinkVersion.Unlock()
|
|
return mock.DeviceGetNvLinkVersionFunc(device, n)
|
|
}
|
|
|
|
// DeviceGetNvLinkVersionCalls gets all the calls that were made to DeviceGetNvLinkVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetNvLinkVersionCalls())
|
|
func (mock *Interface) DeviceGetNvLinkVersionCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceGetNvLinkVersion.RLock()
|
|
calls = mock.calls.DeviceGetNvLinkVersion
|
|
mock.lockDeviceGetNvLinkVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetP2PStatus calls DeviceGetP2PStatusFunc.
|
|
func (mock *Interface) DeviceGetP2PStatus(device1 nvml.Device, device2 nvml.Device, gpuP2PCapsIndex nvml.GpuP2PCapsIndex) (nvml.GpuP2PStatus, nvml.Return) {
|
|
if mock.DeviceGetP2PStatusFunc == nil {
|
|
panic("Interface.DeviceGetP2PStatusFunc: method is nil but Interface.DeviceGetP2PStatus was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device1 nvml.Device
|
|
Device2 nvml.Device
|
|
GpuP2PCapsIndex nvml.GpuP2PCapsIndex
|
|
}{
|
|
Device1: device1,
|
|
Device2: device2,
|
|
GpuP2PCapsIndex: gpuP2PCapsIndex,
|
|
}
|
|
mock.lockDeviceGetP2PStatus.Lock()
|
|
mock.calls.DeviceGetP2PStatus = append(mock.calls.DeviceGetP2PStatus, callInfo)
|
|
mock.lockDeviceGetP2PStatus.Unlock()
|
|
return mock.DeviceGetP2PStatusFunc(device1, device2, gpuP2PCapsIndex)
|
|
}
|
|
|
|
// DeviceGetP2PStatusCalls gets all the calls that were made to DeviceGetP2PStatus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetP2PStatusCalls())
|
|
func (mock *Interface) DeviceGetP2PStatusCalls() []struct {
|
|
Device1 nvml.Device
|
|
Device2 nvml.Device
|
|
GpuP2PCapsIndex nvml.GpuP2PCapsIndex
|
|
} {
|
|
var calls []struct {
|
|
Device1 nvml.Device
|
|
Device2 nvml.Device
|
|
GpuP2PCapsIndex nvml.GpuP2PCapsIndex
|
|
}
|
|
mock.lockDeviceGetP2PStatus.RLock()
|
|
calls = mock.calls.DeviceGetP2PStatus
|
|
mock.lockDeviceGetP2PStatus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPciInfo calls DeviceGetPciInfoFunc.
|
|
func (mock *Interface) DeviceGetPciInfo(device nvml.Device) (nvml.PciInfo, nvml.Return) {
|
|
if mock.DeviceGetPciInfoFunc == nil {
|
|
panic("Interface.DeviceGetPciInfoFunc: method is nil but Interface.DeviceGetPciInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetPciInfo.Lock()
|
|
mock.calls.DeviceGetPciInfo = append(mock.calls.DeviceGetPciInfo, callInfo)
|
|
mock.lockDeviceGetPciInfo.Unlock()
|
|
return mock.DeviceGetPciInfoFunc(device)
|
|
}
|
|
|
|
// DeviceGetPciInfoCalls gets all the calls that were made to DeviceGetPciInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPciInfoCalls())
|
|
func (mock *Interface) DeviceGetPciInfoCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetPciInfo.RLock()
|
|
calls = mock.calls.DeviceGetPciInfo
|
|
mock.lockDeviceGetPciInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPcieLinkMaxSpeed calls DeviceGetPcieLinkMaxSpeedFunc.
|
|
func (mock *Interface) DeviceGetPcieLinkMaxSpeed(device nvml.Device) (uint32, nvml.Return) {
|
|
if mock.DeviceGetPcieLinkMaxSpeedFunc == nil {
|
|
panic("Interface.DeviceGetPcieLinkMaxSpeedFunc: method is nil but Interface.DeviceGetPcieLinkMaxSpeed was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetPcieLinkMaxSpeed.Lock()
|
|
mock.calls.DeviceGetPcieLinkMaxSpeed = append(mock.calls.DeviceGetPcieLinkMaxSpeed, callInfo)
|
|
mock.lockDeviceGetPcieLinkMaxSpeed.Unlock()
|
|
return mock.DeviceGetPcieLinkMaxSpeedFunc(device)
|
|
}
|
|
|
|
// DeviceGetPcieLinkMaxSpeedCalls gets all the calls that were made to DeviceGetPcieLinkMaxSpeed.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPcieLinkMaxSpeedCalls())
|
|
func (mock *Interface) DeviceGetPcieLinkMaxSpeedCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetPcieLinkMaxSpeed.RLock()
|
|
calls = mock.calls.DeviceGetPcieLinkMaxSpeed
|
|
mock.lockDeviceGetPcieLinkMaxSpeed.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPcieReplayCounter calls DeviceGetPcieReplayCounterFunc.
|
|
func (mock *Interface) DeviceGetPcieReplayCounter(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetPcieReplayCounterFunc == nil {
|
|
panic("Interface.DeviceGetPcieReplayCounterFunc: method is nil but Interface.DeviceGetPcieReplayCounter was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetPcieReplayCounter.Lock()
|
|
mock.calls.DeviceGetPcieReplayCounter = append(mock.calls.DeviceGetPcieReplayCounter, callInfo)
|
|
mock.lockDeviceGetPcieReplayCounter.Unlock()
|
|
return mock.DeviceGetPcieReplayCounterFunc(device)
|
|
}
|
|
|
|
// DeviceGetPcieReplayCounterCalls gets all the calls that were made to DeviceGetPcieReplayCounter.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPcieReplayCounterCalls())
|
|
func (mock *Interface) DeviceGetPcieReplayCounterCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetPcieReplayCounter.RLock()
|
|
calls = mock.calls.DeviceGetPcieReplayCounter
|
|
mock.lockDeviceGetPcieReplayCounter.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPcieSpeed calls DeviceGetPcieSpeedFunc.
|
|
func (mock *Interface) DeviceGetPcieSpeed(device nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceGetPcieSpeedFunc == nil {
|
|
panic("Interface.DeviceGetPcieSpeedFunc: method is nil but Interface.DeviceGetPcieSpeed was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetPcieSpeed.Lock()
|
|
mock.calls.DeviceGetPcieSpeed = append(mock.calls.DeviceGetPcieSpeed, callInfo)
|
|
mock.lockDeviceGetPcieSpeed.Unlock()
|
|
return mock.DeviceGetPcieSpeedFunc(device)
|
|
}
|
|
|
|
// DeviceGetPcieSpeedCalls gets all the calls that were made to DeviceGetPcieSpeed.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPcieSpeedCalls())
|
|
func (mock *Interface) DeviceGetPcieSpeedCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetPcieSpeed.RLock()
|
|
calls = mock.calls.DeviceGetPcieSpeed
|
|
mock.lockDeviceGetPcieSpeed.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPcieThroughput calls DeviceGetPcieThroughputFunc.
|
|
func (mock *Interface) DeviceGetPcieThroughput(device nvml.Device, pcieUtilCounter nvml.PcieUtilCounter) (uint32, nvml.Return) {
|
|
if mock.DeviceGetPcieThroughputFunc == nil {
|
|
panic("Interface.DeviceGetPcieThroughputFunc: method is nil but Interface.DeviceGetPcieThroughput was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
PcieUtilCounter nvml.PcieUtilCounter
|
|
}{
|
|
Device: device,
|
|
PcieUtilCounter: pcieUtilCounter,
|
|
}
|
|
mock.lockDeviceGetPcieThroughput.Lock()
|
|
mock.calls.DeviceGetPcieThroughput = append(mock.calls.DeviceGetPcieThroughput, callInfo)
|
|
mock.lockDeviceGetPcieThroughput.Unlock()
|
|
return mock.DeviceGetPcieThroughputFunc(device, pcieUtilCounter)
|
|
}
|
|
|
|
// DeviceGetPcieThroughputCalls gets all the calls that were made to DeviceGetPcieThroughput.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPcieThroughputCalls())
|
|
func (mock *Interface) DeviceGetPcieThroughputCalls() []struct {
|
|
Device nvml.Device
|
|
PcieUtilCounter nvml.PcieUtilCounter
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
PcieUtilCounter nvml.PcieUtilCounter
|
|
}
|
|
mock.lockDeviceGetPcieThroughput.RLock()
|
|
calls = mock.calls.DeviceGetPcieThroughput
|
|
mock.lockDeviceGetPcieThroughput.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPerformanceState calls DeviceGetPerformanceStateFunc.
|
|
func (mock *Interface) DeviceGetPerformanceState(device nvml.Device) (nvml.Pstates, nvml.Return) {
|
|
if mock.DeviceGetPerformanceStateFunc == nil {
|
|
panic("Interface.DeviceGetPerformanceStateFunc: method is nil but Interface.DeviceGetPerformanceState was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetPerformanceState.Lock()
|
|
mock.calls.DeviceGetPerformanceState = append(mock.calls.DeviceGetPerformanceState, callInfo)
|
|
mock.lockDeviceGetPerformanceState.Unlock()
|
|
return mock.DeviceGetPerformanceStateFunc(device)
|
|
}
|
|
|
|
// DeviceGetPerformanceStateCalls gets all the calls that were made to DeviceGetPerformanceState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPerformanceStateCalls())
|
|
func (mock *Interface) DeviceGetPerformanceStateCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetPerformanceState.RLock()
|
|
calls = mock.calls.DeviceGetPerformanceState
|
|
mock.lockDeviceGetPerformanceState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPersistenceMode calls DeviceGetPersistenceModeFunc.
|
|
func (mock *Interface) DeviceGetPersistenceMode(device nvml.Device) (nvml.EnableState, nvml.Return) {
|
|
if mock.DeviceGetPersistenceModeFunc == nil {
|
|
panic("Interface.DeviceGetPersistenceModeFunc: method is nil but Interface.DeviceGetPersistenceMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetPersistenceMode.Lock()
|
|
mock.calls.DeviceGetPersistenceMode = append(mock.calls.DeviceGetPersistenceMode, callInfo)
|
|
mock.lockDeviceGetPersistenceMode.Unlock()
|
|
return mock.DeviceGetPersistenceModeFunc(device)
|
|
}
|
|
|
|
// DeviceGetPersistenceModeCalls gets all the calls that were made to DeviceGetPersistenceMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPersistenceModeCalls())
|
|
func (mock *Interface) DeviceGetPersistenceModeCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetPersistenceMode.RLock()
|
|
calls = mock.calls.DeviceGetPersistenceMode
|
|
mock.lockDeviceGetPersistenceMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPgpuMetadataString calls DeviceGetPgpuMetadataStringFunc.
|
|
func (mock *Interface) DeviceGetPgpuMetadataString(device nvml.Device) (string, nvml.Return) {
|
|
if mock.DeviceGetPgpuMetadataStringFunc == nil {
|
|
panic("Interface.DeviceGetPgpuMetadataStringFunc: method is nil but Interface.DeviceGetPgpuMetadataString was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetPgpuMetadataString.Lock()
|
|
mock.calls.DeviceGetPgpuMetadataString = append(mock.calls.DeviceGetPgpuMetadataString, callInfo)
|
|
mock.lockDeviceGetPgpuMetadataString.Unlock()
|
|
return mock.DeviceGetPgpuMetadataStringFunc(device)
|
|
}
|
|
|
|
// DeviceGetPgpuMetadataStringCalls gets all the calls that were made to DeviceGetPgpuMetadataString.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPgpuMetadataStringCalls())
|
|
func (mock *Interface) DeviceGetPgpuMetadataStringCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetPgpuMetadataString.RLock()
|
|
calls = mock.calls.DeviceGetPgpuMetadataString
|
|
mock.lockDeviceGetPgpuMetadataString.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPowerManagementDefaultLimit calls DeviceGetPowerManagementDefaultLimitFunc.
|
|
func (mock *Interface) DeviceGetPowerManagementDefaultLimit(device nvml.Device) (uint32, nvml.Return) {
|
|
if mock.DeviceGetPowerManagementDefaultLimitFunc == nil {
|
|
panic("Interface.DeviceGetPowerManagementDefaultLimitFunc: method is nil but Interface.DeviceGetPowerManagementDefaultLimit was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetPowerManagementDefaultLimit.Lock()
|
|
mock.calls.DeviceGetPowerManagementDefaultLimit = append(mock.calls.DeviceGetPowerManagementDefaultLimit, callInfo)
|
|
mock.lockDeviceGetPowerManagementDefaultLimit.Unlock()
|
|
return mock.DeviceGetPowerManagementDefaultLimitFunc(device)
|
|
}
|
|
|
|
// DeviceGetPowerManagementDefaultLimitCalls gets all the calls that were made to DeviceGetPowerManagementDefaultLimit.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPowerManagementDefaultLimitCalls())
|
|
func (mock *Interface) DeviceGetPowerManagementDefaultLimitCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetPowerManagementDefaultLimit.RLock()
|
|
calls = mock.calls.DeviceGetPowerManagementDefaultLimit
|
|
mock.lockDeviceGetPowerManagementDefaultLimit.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPowerManagementLimit calls DeviceGetPowerManagementLimitFunc.
|
|
func (mock *Interface) DeviceGetPowerManagementLimit(device nvml.Device) (uint32, nvml.Return) {
|
|
if mock.DeviceGetPowerManagementLimitFunc == nil {
|
|
panic("Interface.DeviceGetPowerManagementLimitFunc: method is nil but Interface.DeviceGetPowerManagementLimit was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetPowerManagementLimit.Lock()
|
|
mock.calls.DeviceGetPowerManagementLimit = append(mock.calls.DeviceGetPowerManagementLimit, callInfo)
|
|
mock.lockDeviceGetPowerManagementLimit.Unlock()
|
|
return mock.DeviceGetPowerManagementLimitFunc(device)
|
|
}
|
|
|
|
// DeviceGetPowerManagementLimitCalls gets all the calls that were made to DeviceGetPowerManagementLimit.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPowerManagementLimitCalls())
|
|
func (mock *Interface) DeviceGetPowerManagementLimitCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetPowerManagementLimit.RLock()
|
|
calls = mock.calls.DeviceGetPowerManagementLimit
|
|
mock.lockDeviceGetPowerManagementLimit.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPowerManagementLimitConstraints calls DeviceGetPowerManagementLimitConstraintsFunc.
|
|
func (mock *Interface) DeviceGetPowerManagementLimitConstraints(device nvml.Device) (uint32, uint32, nvml.Return) {
|
|
if mock.DeviceGetPowerManagementLimitConstraintsFunc == nil {
|
|
panic("Interface.DeviceGetPowerManagementLimitConstraintsFunc: method is nil but Interface.DeviceGetPowerManagementLimitConstraints was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetPowerManagementLimitConstraints.Lock()
|
|
mock.calls.DeviceGetPowerManagementLimitConstraints = append(mock.calls.DeviceGetPowerManagementLimitConstraints, callInfo)
|
|
mock.lockDeviceGetPowerManagementLimitConstraints.Unlock()
|
|
return mock.DeviceGetPowerManagementLimitConstraintsFunc(device)
|
|
}
|
|
|
|
// DeviceGetPowerManagementLimitConstraintsCalls gets all the calls that were made to DeviceGetPowerManagementLimitConstraints.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPowerManagementLimitConstraintsCalls())
|
|
func (mock *Interface) DeviceGetPowerManagementLimitConstraintsCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetPowerManagementLimitConstraints.RLock()
|
|
calls = mock.calls.DeviceGetPowerManagementLimitConstraints
|
|
mock.lockDeviceGetPowerManagementLimitConstraints.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPowerManagementMode calls DeviceGetPowerManagementModeFunc.
|
|
func (mock *Interface) DeviceGetPowerManagementMode(device nvml.Device) (nvml.EnableState, nvml.Return) {
|
|
if mock.DeviceGetPowerManagementModeFunc == nil {
|
|
panic("Interface.DeviceGetPowerManagementModeFunc: method is nil but Interface.DeviceGetPowerManagementMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetPowerManagementMode.Lock()
|
|
mock.calls.DeviceGetPowerManagementMode = append(mock.calls.DeviceGetPowerManagementMode, callInfo)
|
|
mock.lockDeviceGetPowerManagementMode.Unlock()
|
|
return mock.DeviceGetPowerManagementModeFunc(device)
|
|
}
|
|
|
|
// DeviceGetPowerManagementModeCalls gets all the calls that were made to DeviceGetPowerManagementMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPowerManagementModeCalls())
|
|
func (mock *Interface) DeviceGetPowerManagementModeCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetPowerManagementMode.RLock()
|
|
calls = mock.calls.DeviceGetPowerManagementMode
|
|
mock.lockDeviceGetPowerManagementMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPowerSource calls DeviceGetPowerSourceFunc.
|
|
func (mock *Interface) DeviceGetPowerSource(device nvml.Device) (nvml.PowerSource, nvml.Return) {
|
|
if mock.DeviceGetPowerSourceFunc == nil {
|
|
panic("Interface.DeviceGetPowerSourceFunc: method is nil but Interface.DeviceGetPowerSource was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetPowerSource.Lock()
|
|
mock.calls.DeviceGetPowerSource = append(mock.calls.DeviceGetPowerSource, callInfo)
|
|
mock.lockDeviceGetPowerSource.Unlock()
|
|
return mock.DeviceGetPowerSourceFunc(device)
|
|
}
|
|
|
|
// DeviceGetPowerSourceCalls gets all the calls that were made to DeviceGetPowerSource.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPowerSourceCalls())
|
|
func (mock *Interface) DeviceGetPowerSourceCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetPowerSource.RLock()
|
|
calls = mock.calls.DeviceGetPowerSource
|
|
mock.lockDeviceGetPowerSource.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPowerState calls DeviceGetPowerStateFunc.
|
|
func (mock *Interface) DeviceGetPowerState(device nvml.Device) (nvml.Pstates, nvml.Return) {
|
|
if mock.DeviceGetPowerStateFunc == nil {
|
|
panic("Interface.DeviceGetPowerStateFunc: method is nil but Interface.DeviceGetPowerState was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetPowerState.Lock()
|
|
mock.calls.DeviceGetPowerState = append(mock.calls.DeviceGetPowerState, callInfo)
|
|
mock.lockDeviceGetPowerState.Unlock()
|
|
return mock.DeviceGetPowerStateFunc(device)
|
|
}
|
|
|
|
// DeviceGetPowerStateCalls gets all the calls that were made to DeviceGetPowerState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPowerStateCalls())
|
|
func (mock *Interface) DeviceGetPowerStateCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetPowerState.RLock()
|
|
calls = mock.calls.DeviceGetPowerState
|
|
mock.lockDeviceGetPowerState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetPowerUsage calls DeviceGetPowerUsageFunc.
|
|
func (mock *Interface) DeviceGetPowerUsage(device nvml.Device) (uint32, nvml.Return) {
|
|
if mock.DeviceGetPowerUsageFunc == nil {
|
|
panic("Interface.DeviceGetPowerUsageFunc: method is nil but Interface.DeviceGetPowerUsage was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetPowerUsage.Lock()
|
|
mock.calls.DeviceGetPowerUsage = append(mock.calls.DeviceGetPowerUsage, callInfo)
|
|
mock.lockDeviceGetPowerUsage.Unlock()
|
|
return mock.DeviceGetPowerUsageFunc(device)
|
|
}
|
|
|
|
// DeviceGetPowerUsageCalls gets all the calls that were made to DeviceGetPowerUsage.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetPowerUsageCalls())
|
|
func (mock *Interface) DeviceGetPowerUsageCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetPowerUsage.RLock()
|
|
calls = mock.calls.DeviceGetPowerUsage
|
|
mock.lockDeviceGetPowerUsage.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetProcessUtilization calls DeviceGetProcessUtilizationFunc.
|
|
func (mock *Interface) DeviceGetProcessUtilization(device nvml.Device, v uint64) ([]nvml.ProcessUtilizationSample, nvml.Return) {
|
|
if mock.DeviceGetProcessUtilizationFunc == nil {
|
|
panic("Interface.DeviceGetProcessUtilizationFunc: method is nil but Interface.DeviceGetProcessUtilization was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
V uint64
|
|
}{
|
|
Device: device,
|
|
V: v,
|
|
}
|
|
mock.lockDeviceGetProcessUtilization.Lock()
|
|
mock.calls.DeviceGetProcessUtilization = append(mock.calls.DeviceGetProcessUtilization, callInfo)
|
|
mock.lockDeviceGetProcessUtilization.Unlock()
|
|
return mock.DeviceGetProcessUtilizationFunc(device, v)
|
|
}
|
|
|
|
// DeviceGetProcessUtilizationCalls gets all the calls that were made to DeviceGetProcessUtilization.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetProcessUtilizationCalls())
|
|
func (mock *Interface) DeviceGetProcessUtilizationCalls() []struct {
|
|
Device nvml.Device
|
|
V uint64
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
V uint64
|
|
}
|
|
mock.lockDeviceGetProcessUtilization.RLock()
|
|
calls = mock.calls.DeviceGetProcessUtilization
|
|
mock.lockDeviceGetProcessUtilization.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetRemappedRows calls DeviceGetRemappedRowsFunc.
|
|
func (mock *Interface) DeviceGetRemappedRows(device nvml.Device) (int, int, bool, bool, nvml.Return) {
|
|
if mock.DeviceGetRemappedRowsFunc == nil {
|
|
panic("Interface.DeviceGetRemappedRowsFunc: method is nil but Interface.DeviceGetRemappedRows was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetRemappedRows.Lock()
|
|
mock.calls.DeviceGetRemappedRows = append(mock.calls.DeviceGetRemappedRows, callInfo)
|
|
mock.lockDeviceGetRemappedRows.Unlock()
|
|
return mock.DeviceGetRemappedRowsFunc(device)
|
|
}
|
|
|
|
// DeviceGetRemappedRowsCalls gets all the calls that were made to DeviceGetRemappedRows.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetRemappedRowsCalls())
|
|
func (mock *Interface) DeviceGetRemappedRowsCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetRemappedRows.RLock()
|
|
calls = mock.calls.DeviceGetRemappedRows
|
|
mock.lockDeviceGetRemappedRows.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetRetiredPages calls DeviceGetRetiredPagesFunc.
|
|
func (mock *Interface) DeviceGetRetiredPages(device nvml.Device, pageRetirementCause nvml.PageRetirementCause) ([]uint64, nvml.Return) {
|
|
if mock.DeviceGetRetiredPagesFunc == nil {
|
|
panic("Interface.DeviceGetRetiredPagesFunc: method is nil but Interface.DeviceGetRetiredPages was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
}{
|
|
Device: device,
|
|
PageRetirementCause: pageRetirementCause,
|
|
}
|
|
mock.lockDeviceGetRetiredPages.Lock()
|
|
mock.calls.DeviceGetRetiredPages = append(mock.calls.DeviceGetRetiredPages, callInfo)
|
|
mock.lockDeviceGetRetiredPages.Unlock()
|
|
return mock.DeviceGetRetiredPagesFunc(device, pageRetirementCause)
|
|
}
|
|
|
|
// DeviceGetRetiredPagesCalls gets all the calls that were made to DeviceGetRetiredPages.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetRetiredPagesCalls())
|
|
func (mock *Interface) DeviceGetRetiredPagesCalls() []struct {
|
|
Device nvml.Device
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
}
|
|
mock.lockDeviceGetRetiredPages.RLock()
|
|
calls = mock.calls.DeviceGetRetiredPages
|
|
mock.lockDeviceGetRetiredPages.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetRetiredPagesPendingStatus calls DeviceGetRetiredPagesPendingStatusFunc.
|
|
func (mock *Interface) DeviceGetRetiredPagesPendingStatus(device nvml.Device) (nvml.EnableState, nvml.Return) {
|
|
if mock.DeviceGetRetiredPagesPendingStatusFunc == nil {
|
|
panic("Interface.DeviceGetRetiredPagesPendingStatusFunc: method is nil but Interface.DeviceGetRetiredPagesPendingStatus was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetRetiredPagesPendingStatus.Lock()
|
|
mock.calls.DeviceGetRetiredPagesPendingStatus = append(mock.calls.DeviceGetRetiredPagesPendingStatus, callInfo)
|
|
mock.lockDeviceGetRetiredPagesPendingStatus.Unlock()
|
|
return mock.DeviceGetRetiredPagesPendingStatusFunc(device)
|
|
}
|
|
|
|
// DeviceGetRetiredPagesPendingStatusCalls gets all the calls that were made to DeviceGetRetiredPagesPendingStatus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetRetiredPagesPendingStatusCalls())
|
|
func (mock *Interface) DeviceGetRetiredPagesPendingStatusCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetRetiredPagesPendingStatus.RLock()
|
|
calls = mock.calls.DeviceGetRetiredPagesPendingStatus
|
|
mock.lockDeviceGetRetiredPagesPendingStatus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetRetiredPages_v2 calls DeviceGetRetiredPages_v2Func.
|
|
func (mock *Interface) DeviceGetRetiredPages_v2(device nvml.Device, pageRetirementCause nvml.PageRetirementCause) ([]uint64, []uint64, nvml.Return) {
|
|
if mock.DeviceGetRetiredPages_v2Func == nil {
|
|
panic("Interface.DeviceGetRetiredPages_v2Func: method is nil but Interface.DeviceGetRetiredPages_v2 was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
}{
|
|
Device: device,
|
|
PageRetirementCause: pageRetirementCause,
|
|
}
|
|
mock.lockDeviceGetRetiredPages_v2.Lock()
|
|
mock.calls.DeviceGetRetiredPages_v2 = append(mock.calls.DeviceGetRetiredPages_v2, callInfo)
|
|
mock.lockDeviceGetRetiredPages_v2.Unlock()
|
|
return mock.DeviceGetRetiredPages_v2Func(device, pageRetirementCause)
|
|
}
|
|
|
|
// DeviceGetRetiredPages_v2Calls gets all the calls that were made to DeviceGetRetiredPages_v2.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetRetiredPages_v2Calls())
|
|
func (mock *Interface) DeviceGetRetiredPages_v2Calls() []struct {
|
|
Device nvml.Device
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
}
|
|
mock.lockDeviceGetRetiredPages_v2.RLock()
|
|
calls = mock.calls.DeviceGetRetiredPages_v2
|
|
mock.lockDeviceGetRetiredPages_v2.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetRowRemapperHistogram calls DeviceGetRowRemapperHistogramFunc.
|
|
func (mock *Interface) DeviceGetRowRemapperHistogram(device nvml.Device) (nvml.RowRemapperHistogramValues, nvml.Return) {
|
|
if mock.DeviceGetRowRemapperHistogramFunc == nil {
|
|
panic("Interface.DeviceGetRowRemapperHistogramFunc: method is nil but Interface.DeviceGetRowRemapperHistogram was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetRowRemapperHistogram.Lock()
|
|
mock.calls.DeviceGetRowRemapperHistogram = append(mock.calls.DeviceGetRowRemapperHistogram, callInfo)
|
|
mock.lockDeviceGetRowRemapperHistogram.Unlock()
|
|
return mock.DeviceGetRowRemapperHistogramFunc(device)
|
|
}
|
|
|
|
// DeviceGetRowRemapperHistogramCalls gets all the calls that were made to DeviceGetRowRemapperHistogram.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetRowRemapperHistogramCalls())
|
|
func (mock *Interface) DeviceGetRowRemapperHistogramCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetRowRemapperHistogram.RLock()
|
|
calls = mock.calls.DeviceGetRowRemapperHistogram
|
|
mock.lockDeviceGetRowRemapperHistogram.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetSamples calls DeviceGetSamplesFunc.
|
|
func (mock *Interface) DeviceGetSamples(device nvml.Device, samplingType nvml.SamplingType, v uint64) (nvml.ValueType, []nvml.Sample, nvml.Return) {
|
|
if mock.DeviceGetSamplesFunc == nil {
|
|
panic("Interface.DeviceGetSamplesFunc: method is nil but Interface.DeviceGetSamples was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
SamplingType nvml.SamplingType
|
|
V uint64
|
|
}{
|
|
Device: device,
|
|
SamplingType: samplingType,
|
|
V: v,
|
|
}
|
|
mock.lockDeviceGetSamples.Lock()
|
|
mock.calls.DeviceGetSamples = append(mock.calls.DeviceGetSamples, callInfo)
|
|
mock.lockDeviceGetSamples.Unlock()
|
|
return mock.DeviceGetSamplesFunc(device, samplingType, v)
|
|
}
|
|
|
|
// DeviceGetSamplesCalls gets all the calls that were made to DeviceGetSamples.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetSamplesCalls())
|
|
func (mock *Interface) DeviceGetSamplesCalls() []struct {
|
|
Device nvml.Device
|
|
SamplingType nvml.SamplingType
|
|
V uint64
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
SamplingType nvml.SamplingType
|
|
V uint64
|
|
}
|
|
mock.lockDeviceGetSamples.RLock()
|
|
calls = mock.calls.DeviceGetSamples
|
|
mock.lockDeviceGetSamples.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetSerial calls DeviceGetSerialFunc.
|
|
func (mock *Interface) DeviceGetSerial(device nvml.Device) (string, nvml.Return) {
|
|
if mock.DeviceGetSerialFunc == nil {
|
|
panic("Interface.DeviceGetSerialFunc: method is nil but Interface.DeviceGetSerial was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetSerial.Lock()
|
|
mock.calls.DeviceGetSerial = append(mock.calls.DeviceGetSerial, callInfo)
|
|
mock.lockDeviceGetSerial.Unlock()
|
|
return mock.DeviceGetSerialFunc(device)
|
|
}
|
|
|
|
// DeviceGetSerialCalls gets all the calls that were made to DeviceGetSerial.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetSerialCalls())
|
|
func (mock *Interface) DeviceGetSerialCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetSerial.RLock()
|
|
calls = mock.calls.DeviceGetSerial
|
|
mock.lockDeviceGetSerial.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetSupportedClocksThrottleReasons calls DeviceGetSupportedClocksThrottleReasonsFunc.
|
|
func (mock *Interface) DeviceGetSupportedClocksThrottleReasons(device nvml.Device) (uint64, nvml.Return) {
|
|
if mock.DeviceGetSupportedClocksThrottleReasonsFunc == nil {
|
|
panic("Interface.DeviceGetSupportedClocksThrottleReasonsFunc: method is nil but Interface.DeviceGetSupportedClocksThrottleReasons was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetSupportedClocksThrottleReasons.Lock()
|
|
mock.calls.DeviceGetSupportedClocksThrottleReasons = append(mock.calls.DeviceGetSupportedClocksThrottleReasons, callInfo)
|
|
mock.lockDeviceGetSupportedClocksThrottleReasons.Unlock()
|
|
return mock.DeviceGetSupportedClocksThrottleReasonsFunc(device)
|
|
}
|
|
|
|
// DeviceGetSupportedClocksThrottleReasonsCalls gets all the calls that were made to DeviceGetSupportedClocksThrottleReasons.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetSupportedClocksThrottleReasonsCalls())
|
|
func (mock *Interface) DeviceGetSupportedClocksThrottleReasonsCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetSupportedClocksThrottleReasons.RLock()
|
|
calls = mock.calls.DeviceGetSupportedClocksThrottleReasons
|
|
mock.lockDeviceGetSupportedClocksThrottleReasons.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetSupportedEventTypes calls DeviceGetSupportedEventTypesFunc.
|
|
func (mock *Interface) DeviceGetSupportedEventTypes(device nvml.Device) (uint64, nvml.Return) {
|
|
if mock.DeviceGetSupportedEventTypesFunc == nil {
|
|
panic("Interface.DeviceGetSupportedEventTypesFunc: method is nil but Interface.DeviceGetSupportedEventTypes was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetSupportedEventTypes.Lock()
|
|
mock.calls.DeviceGetSupportedEventTypes = append(mock.calls.DeviceGetSupportedEventTypes, callInfo)
|
|
mock.lockDeviceGetSupportedEventTypes.Unlock()
|
|
return mock.DeviceGetSupportedEventTypesFunc(device)
|
|
}
|
|
|
|
// DeviceGetSupportedEventTypesCalls gets all the calls that were made to DeviceGetSupportedEventTypes.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetSupportedEventTypesCalls())
|
|
func (mock *Interface) DeviceGetSupportedEventTypesCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetSupportedEventTypes.RLock()
|
|
calls = mock.calls.DeviceGetSupportedEventTypes
|
|
mock.lockDeviceGetSupportedEventTypes.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetSupportedGraphicsClocks calls DeviceGetSupportedGraphicsClocksFunc.
|
|
func (mock *Interface) DeviceGetSupportedGraphicsClocks(device nvml.Device, n int) (int, uint32, nvml.Return) {
|
|
if mock.DeviceGetSupportedGraphicsClocksFunc == nil {
|
|
panic("Interface.DeviceGetSupportedGraphicsClocksFunc: method is nil but Interface.DeviceGetSupportedGraphicsClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceGetSupportedGraphicsClocks.Lock()
|
|
mock.calls.DeviceGetSupportedGraphicsClocks = append(mock.calls.DeviceGetSupportedGraphicsClocks, callInfo)
|
|
mock.lockDeviceGetSupportedGraphicsClocks.Unlock()
|
|
return mock.DeviceGetSupportedGraphicsClocksFunc(device, n)
|
|
}
|
|
|
|
// DeviceGetSupportedGraphicsClocksCalls gets all the calls that were made to DeviceGetSupportedGraphicsClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetSupportedGraphicsClocksCalls())
|
|
func (mock *Interface) DeviceGetSupportedGraphicsClocksCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceGetSupportedGraphicsClocks.RLock()
|
|
calls = mock.calls.DeviceGetSupportedGraphicsClocks
|
|
mock.lockDeviceGetSupportedGraphicsClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetSupportedMemoryClocks calls DeviceGetSupportedMemoryClocksFunc.
|
|
func (mock *Interface) DeviceGetSupportedMemoryClocks(device nvml.Device) (int, uint32, nvml.Return) {
|
|
if mock.DeviceGetSupportedMemoryClocksFunc == nil {
|
|
panic("Interface.DeviceGetSupportedMemoryClocksFunc: method is nil but Interface.DeviceGetSupportedMemoryClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetSupportedMemoryClocks.Lock()
|
|
mock.calls.DeviceGetSupportedMemoryClocks = append(mock.calls.DeviceGetSupportedMemoryClocks, callInfo)
|
|
mock.lockDeviceGetSupportedMemoryClocks.Unlock()
|
|
return mock.DeviceGetSupportedMemoryClocksFunc(device)
|
|
}
|
|
|
|
// DeviceGetSupportedMemoryClocksCalls gets all the calls that were made to DeviceGetSupportedMemoryClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetSupportedMemoryClocksCalls())
|
|
func (mock *Interface) DeviceGetSupportedMemoryClocksCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetSupportedMemoryClocks.RLock()
|
|
calls = mock.calls.DeviceGetSupportedMemoryClocks
|
|
mock.lockDeviceGetSupportedMemoryClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetSupportedPerformanceStates calls DeviceGetSupportedPerformanceStatesFunc.
|
|
func (mock *Interface) DeviceGetSupportedPerformanceStates(device nvml.Device) ([]nvml.Pstates, nvml.Return) {
|
|
if mock.DeviceGetSupportedPerformanceStatesFunc == nil {
|
|
panic("Interface.DeviceGetSupportedPerformanceStatesFunc: method is nil but Interface.DeviceGetSupportedPerformanceStates was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetSupportedPerformanceStates.Lock()
|
|
mock.calls.DeviceGetSupportedPerformanceStates = append(mock.calls.DeviceGetSupportedPerformanceStates, callInfo)
|
|
mock.lockDeviceGetSupportedPerformanceStates.Unlock()
|
|
return mock.DeviceGetSupportedPerformanceStatesFunc(device)
|
|
}
|
|
|
|
// DeviceGetSupportedPerformanceStatesCalls gets all the calls that were made to DeviceGetSupportedPerformanceStates.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetSupportedPerformanceStatesCalls())
|
|
func (mock *Interface) DeviceGetSupportedPerformanceStatesCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetSupportedPerformanceStates.RLock()
|
|
calls = mock.calls.DeviceGetSupportedPerformanceStates
|
|
mock.lockDeviceGetSupportedPerformanceStates.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetSupportedVgpus calls DeviceGetSupportedVgpusFunc.
|
|
func (mock *Interface) DeviceGetSupportedVgpus(device nvml.Device) ([]nvml.VgpuTypeId, nvml.Return) {
|
|
if mock.DeviceGetSupportedVgpusFunc == nil {
|
|
panic("Interface.DeviceGetSupportedVgpusFunc: method is nil but Interface.DeviceGetSupportedVgpus was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetSupportedVgpus.Lock()
|
|
mock.calls.DeviceGetSupportedVgpus = append(mock.calls.DeviceGetSupportedVgpus, callInfo)
|
|
mock.lockDeviceGetSupportedVgpus.Unlock()
|
|
return mock.DeviceGetSupportedVgpusFunc(device)
|
|
}
|
|
|
|
// DeviceGetSupportedVgpusCalls gets all the calls that were made to DeviceGetSupportedVgpus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetSupportedVgpusCalls())
|
|
func (mock *Interface) DeviceGetSupportedVgpusCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetSupportedVgpus.RLock()
|
|
calls = mock.calls.DeviceGetSupportedVgpus
|
|
mock.lockDeviceGetSupportedVgpus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetTargetFanSpeed calls DeviceGetTargetFanSpeedFunc.
|
|
func (mock *Interface) DeviceGetTargetFanSpeed(device nvml.Device, n int) (int, nvml.Return) {
|
|
if mock.DeviceGetTargetFanSpeedFunc == nil {
|
|
panic("Interface.DeviceGetTargetFanSpeedFunc: method is nil but Interface.DeviceGetTargetFanSpeed was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceGetTargetFanSpeed.Lock()
|
|
mock.calls.DeviceGetTargetFanSpeed = append(mock.calls.DeviceGetTargetFanSpeed, callInfo)
|
|
mock.lockDeviceGetTargetFanSpeed.Unlock()
|
|
return mock.DeviceGetTargetFanSpeedFunc(device, n)
|
|
}
|
|
|
|
// DeviceGetTargetFanSpeedCalls gets all the calls that were made to DeviceGetTargetFanSpeed.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetTargetFanSpeedCalls())
|
|
func (mock *Interface) DeviceGetTargetFanSpeedCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceGetTargetFanSpeed.RLock()
|
|
calls = mock.calls.DeviceGetTargetFanSpeed
|
|
mock.lockDeviceGetTargetFanSpeed.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetTemperature calls DeviceGetTemperatureFunc.
|
|
func (mock *Interface) DeviceGetTemperature(device nvml.Device, temperatureSensors nvml.TemperatureSensors) (uint32, nvml.Return) {
|
|
if mock.DeviceGetTemperatureFunc == nil {
|
|
panic("Interface.DeviceGetTemperatureFunc: method is nil but Interface.DeviceGetTemperature was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
TemperatureSensors nvml.TemperatureSensors
|
|
}{
|
|
Device: device,
|
|
TemperatureSensors: temperatureSensors,
|
|
}
|
|
mock.lockDeviceGetTemperature.Lock()
|
|
mock.calls.DeviceGetTemperature = append(mock.calls.DeviceGetTemperature, callInfo)
|
|
mock.lockDeviceGetTemperature.Unlock()
|
|
return mock.DeviceGetTemperatureFunc(device, temperatureSensors)
|
|
}
|
|
|
|
// DeviceGetTemperatureCalls gets all the calls that were made to DeviceGetTemperature.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetTemperatureCalls())
|
|
func (mock *Interface) DeviceGetTemperatureCalls() []struct {
|
|
Device nvml.Device
|
|
TemperatureSensors nvml.TemperatureSensors
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
TemperatureSensors nvml.TemperatureSensors
|
|
}
|
|
mock.lockDeviceGetTemperature.RLock()
|
|
calls = mock.calls.DeviceGetTemperature
|
|
mock.lockDeviceGetTemperature.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetTemperatureThreshold calls DeviceGetTemperatureThresholdFunc.
|
|
func (mock *Interface) DeviceGetTemperatureThreshold(device nvml.Device, temperatureThresholds nvml.TemperatureThresholds) (uint32, nvml.Return) {
|
|
if mock.DeviceGetTemperatureThresholdFunc == nil {
|
|
panic("Interface.DeviceGetTemperatureThresholdFunc: method is nil but Interface.DeviceGetTemperatureThreshold was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
}{
|
|
Device: device,
|
|
TemperatureThresholds: temperatureThresholds,
|
|
}
|
|
mock.lockDeviceGetTemperatureThreshold.Lock()
|
|
mock.calls.DeviceGetTemperatureThreshold = append(mock.calls.DeviceGetTemperatureThreshold, callInfo)
|
|
mock.lockDeviceGetTemperatureThreshold.Unlock()
|
|
return mock.DeviceGetTemperatureThresholdFunc(device, temperatureThresholds)
|
|
}
|
|
|
|
// DeviceGetTemperatureThresholdCalls gets all the calls that were made to DeviceGetTemperatureThreshold.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetTemperatureThresholdCalls())
|
|
func (mock *Interface) DeviceGetTemperatureThresholdCalls() []struct {
|
|
Device nvml.Device
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
}
|
|
mock.lockDeviceGetTemperatureThreshold.RLock()
|
|
calls = mock.calls.DeviceGetTemperatureThreshold
|
|
mock.lockDeviceGetTemperatureThreshold.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetThermalSettings calls DeviceGetThermalSettingsFunc.
|
|
func (mock *Interface) DeviceGetThermalSettings(device nvml.Device, v uint32) (nvml.GpuThermalSettings, nvml.Return) {
|
|
if mock.DeviceGetThermalSettingsFunc == nil {
|
|
panic("Interface.DeviceGetThermalSettingsFunc: method is nil but Interface.DeviceGetThermalSettings was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
V uint32
|
|
}{
|
|
Device: device,
|
|
V: v,
|
|
}
|
|
mock.lockDeviceGetThermalSettings.Lock()
|
|
mock.calls.DeviceGetThermalSettings = append(mock.calls.DeviceGetThermalSettings, callInfo)
|
|
mock.lockDeviceGetThermalSettings.Unlock()
|
|
return mock.DeviceGetThermalSettingsFunc(device, v)
|
|
}
|
|
|
|
// DeviceGetThermalSettingsCalls gets all the calls that were made to DeviceGetThermalSettings.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetThermalSettingsCalls())
|
|
func (mock *Interface) DeviceGetThermalSettingsCalls() []struct {
|
|
Device nvml.Device
|
|
V uint32
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
V uint32
|
|
}
|
|
mock.lockDeviceGetThermalSettings.RLock()
|
|
calls = mock.calls.DeviceGetThermalSettings
|
|
mock.lockDeviceGetThermalSettings.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetTopologyCommonAncestor calls DeviceGetTopologyCommonAncestorFunc.
|
|
func (mock *Interface) DeviceGetTopologyCommonAncestor(device1 nvml.Device, device2 nvml.Device) (nvml.GpuTopologyLevel, nvml.Return) {
|
|
if mock.DeviceGetTopologyCommonAncestorFunc == nil {
|
|
panic("Interface.DeviceGetTopologyCommonAncestorFunc: method is nil but Interface.DeviceGetTopologyCommonAncestor was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device1 nvml.Device
|
|
Device2 nvml.Device
|
|
}{
|
|
Device1: device1,
|
|
Device2: device2,
|
|
}
|
|
mock.lockDeviceGetTopologyCommonAncestor.Lock()
|
|
mock.calls.DeviceGetTopologyCommonAncestor = append(mock.calls.DeviceGetTopologyCommonAncestor, callInfo)
|
|
mock.lockDeviceGetTopologyCommonAncestor.Unlock()
|
|
return mock.DeviceGetTopologyCommonAncestorFunc(device1, device2)
|
|
}
|
|
|
|
// DeviceGetTopologyCommonAncestorCalls gets all the calls that were made to DeviceGetTopologyCommonAncestor.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetTopologyCommonAncestorCalls())
|
|
func (mock *Interface) DeviceGetTopologyCommonAncestorCalls() []struct {
|
|
Device1 nvml.Device
|
|
Device2 nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device1 nvml.Device
|
|
Device2 nvml.Device
|
|
}
|
|
mock.lockDeviceGetTopologyCommonAncestor.RLock()
|
|
calls = mock.calls.DeviceGetTopologyCommonAncestor
|
|
mock.lockDeviceGetTopologyCommonAncestor.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetTopologyNearestGpus calls DeviceGetTopologyNearestGpusFunc.
|
|
func (mock *Interface) DeviceGetTopologyNearestGpus(device nvml.Device, gpuTopologyLevel nvml.GpuTopologyLevel) ([]nvml.Device, nvml.Return) {
|
|
if mock.DeviceGetTopologyNearestGpusFunc == nil {
|
|
panic("Interface.DeviceGetTopologyNearestGpusFunc: method is nil but Interface.DeviceGetTopologyNearestGpus was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
GpuTopologyLevel nvml.GpuTopologyLevel
|
|
}{
|
|
Device: device,
|
|
GpuTopologyLevel: gpuTopologyLevel,
|
|
}
|
|
mock.lockDeviceGetTopologyNearestGpus.Lock()
|
|
mock.calls.DeviceGetTopologyNearestGpus = append(mock.calls.DeviceGetTopologyNearestGpus, callInfo)
|
|
mock.lockDeviceGetTopologyNearestGpus.Unlock()
|
|
return mock.DeviceGetTopologyNearestGpusFunc(device, gpuTopologyLevel)
|
|
}
|
|
|
|
// DeviceGetTopologyNearestGpusCalls gets all the calls that were made to DeviceGetTopologyNearestGpus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetTopologyNearestGpusCalls())
|
|
func (mock *Interface) DeviceGetTopologyNearestGpusCalls() []struct {
|
|
Device nvml.Device
|
|
GpuTopologyLevel nvml.GpuTopologyLevel
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
GpuTopologyLevel nvml.GpuTopologyLevel
|
|
}
|
|
mock.lockDeviceGetTopologyNearestGpus.RLock()
|
|
calls = mock.calls.DeviceGetTopologyNearestGpus
|
|
mock.lockDeviceGetTopologyNearestGpus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetTotalEccErrors calls DeviceGetTotalEccErrorsFunc.
|
|
func (mock *Interface) DeviceGetTotalEccErrors(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (uint64, nvml.Return) {
|
|
if mock.DeviceGetTotalEccErrorsFunc == nil {
|
|
panic("Interface.DeviceGetTotalEccErrorsFunc: method is nil but Interface.DeviceGetTotalEccErrors was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
}{
|
|
Device: device,
|
|
MemoryErrorType: memoryErrorType,
|
|
EccCounterType: eccCounterType,
|
|
}
|
|
mock.lockDeviceGetTotalEccErrors.Lock()
|
|
mock.calls.DeviceGetTotalEccErrors = append(mock.calls.DeviceGetTotalEccErrors, callInfo)
|
|
mock.lockDeviceGetTotalEccErrors.Unlock()
|
|
return mock.DeviceGetTotalEccErrorsFunc(device, memoryErrorType, eccCounterType)
|
|
}
|
|
|
|
// DeviceGetTotalEccErrorsCalls gets all the calls that were made to DeviceGetTotalEccErrors.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetTotalEccErrorsCalls())
|
|
func (mock *Interface) DeviceGetTotalEccErrorsCalls() []struct {
|
|
Device nvml.Device
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
}
|
|
mock.lockDeviceGetTotalEccErrors.RLock()
|
|
calls = mock.calls.DeviceGetTotalEccErrors
|
|
mock.lockDeviceGetTotalEccErrors.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetTotalEnergyConsumption calls DeviceGetTotalEnergyConsumptionFunc.
|
|
func (mock *Interface) DeviceGetTotalEnergyConsumption(device nvml.Device) (uint64, nvml.Return) {
|
|
if mock.DeviceGetTotalEnergyConsumptionFunc == nil {
|
|
panic("Interface.DeviceGetTotalEnergyConsumptionFunc: method is nil but Interface.DeviceGetTotalEnergyConsumption was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetTotalEnergyConsumption.Lock()
|
|
mock.calls.DeviceGetTotalEnergyConsumption = append(mock.calls.DeviceGetTotalEnergyConsumption, callInfo)
|
|
mock.lockDeviceGetTotalEnergyConsumption.Unlock()
|
|
return mock.DeviceGetTotalEnergyConsumptionFunc(device)
|
|
}
|
|
|
|
// DeviceGetTotalEnergyConsumptionCalls gets all the calls that were made to DeviceGetTotalEnergyConsumption.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetTotalEnergyConsumptionCalls())
|
|
func (mock *Interface) DeviceGetTotalEnergyConsumptionCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetTotalEnergyConsumption.RLock()
|
|
calls = mock.calls.DeviceGetTotalEnergyConsumption
|
|
mock.lockDeviceGetTotalEnergyConsumption.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetUUID calls DeviceGetUUIDFunc.
|
|
func (mock *Interface) DeviceGetUUID(device nvml.Device) (string, nvml.Return) {
|
|
if mock.DeviceGetUUIDFunc == nil {
|
|
panic("Interface.DeviceGetUUIDFunc: method is nil but Interface.DeviceGetUUID was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetUUID.Lock()
|
|
mock.calls.DeviceGetUUID = append(mock.calls.DeviceGetUUID, callInfo)
|
|
mock.lockDeviceGetUUID.Unlock()
|
|
return mock.DeviceGetUUIDFunc(device)
|
|
}
|
|
|
|
// DeviceGetUUIDCalls gets all the calls that were made to DeviceGetUUID.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetUUIDCalls())
|
|
func (mock *Interface) DeviceGetUUIDCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetUUID.RLock()
|
|
calls = mock.calls.DeviceGetUUID
|
|
mock.lockDeviceGetUUID.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetUtilizationRates calls DeviceGetUtilizationRatesFunc.
|
|
func (mock *Interface) DeviceGetUtilizationRates(device nvml.Device) (nvml.Utilization, nvml.Return) {
|
|
if mock.DeviceGetUtilizationRatesFunc == nil {
|
|
panic("Interface.DeviceGetUtilizationRatesFunc: method is nil but Interface.DeviceGetUtilizationRates was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetUtilizationRates.Lock()
|
|
mock.calls.DeviceGetUtilizationRates = append(mock.calls.DeviceGetUtilizationRates, callInfo)
|
|
mock.lockDeviceGetUtilizationRates.Unlock()
|
|
return mock.DeviceGetUtilizationRatesFunc(device)
|
|
}
|
|
|
|
// DeviceGetUtilizationRatesCalls gets all the calls that were made to DeviceGetUtilizationRates.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetUtilizationRatesCalls())
|
|
func (mock *Interface) DeviceGetUtilizationRatesCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetUtilizationRates.RLock()
|
|
calls = mock.calls.DeviceGetUtilizationRates
|
|
mock.lockDeviceGetUtilizationRates.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetVbiosVersion calls DeviceGetVbiosVersionFunc.
|
|
func (mock *Interface) DeviceGetVbiosVersion(device nvml.Device) (string, nvml.Return) {
|
|
if mock.DeviceGetVbiosVersionFunc == nil {
|
|
panic("Interface.DeviceGetVbiosVersionFunc: method is nil but Interface.DeviceGetVbiosVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetVbiosVersion.Lock()
|
|
mock.calls.DeviceGetVbiosVersion = append(mock.calls.DeviceGetVbiosVersion, callInfo)
|
|
mock.lockDeviceGetVbiosVersion.Unlock()
|
|
return mock.DeviceGetVbiosVersionFunc(device)
|
|
}
|
|
|
|
// DeviceGetVbiosVersionCalls gets all the calls that were made to DeviceGetVbiosVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetVbiosVersionCalls())
|
|
func (mock *Interface) DeviceGetVbiosVersionCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetVbiosVersion.RLock()
|
|
calls = mock.calls.DeviceGetVbiosVersion
|
|
mock.lockDeviceGetVbiosVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetVgpuCapabilities calls DeviceGetVgpuCapabilitiesFunc.
|
|
func (mock *Interface) DeviceGetVgpuCapabilities(device nvml.Device, deviceVgpuCapability nvml.DeviceVgpuCapability) (bool, nvml.Return) {
|
|
if mock.DeviceGetVgpuCapabilitiesFunc == nil {
|
|
panic("Interface.DeviceGetVgpuCapabilitiesFunc: method is nil but Interface.DeviceGetVgpuCapabilities was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
DeviceVgpuCapability nvml.DeviceVgpuCapability
|
|
}{
|
|
Device: device,
|
|
DeviceVgpuCapability: deviceVgpuCapability,
|
|
}
|
|
mock.lockDeviceGetVgpuCapabilities.Lock()
|
|
mock.calls.DeviceGetVgpuCapabilities = append(mock.calls.DeviceGetVgpuCapabilities, callInfo)
|
|
mock.lockDeviceGetVgpuCapabilities.Unlock()
|
|
return mock.DeviceGetVgpuCapabilitiesFunc(device, deviceVgpuCapability)
|
|
}
|
|
|
|
// DeviceGetVgpuCapabilitiesCalls gets all the calls that were made to DeviceGetVgpuCapabilities.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetVgpuCapabilitiesCalls())
|
|
func (mock *Interface) DeviceGetVgpuCapabilitiesCalls() []struct {
|
|
Device nvml.Device
|
|
DeviceVgpuCapability nvml.DeviceVgpuCapability
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
DeviceVgpuCapability nvml.DeviceVgpuCapability
|
|
}
|
|
mock.lockDeviceGetVgpuCapabilities.RLock()
|
|
calls = mock.calls.DeviceGetVgpuCapabilities
|
|
mock.lockDeviceGetVgpuCapabilities.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetVgpuMetadata calls DeviceGetVgpuMetadataFunc.
|
|
func (mock *Interface) DeviceGetVgpuMetadata(device nvml.Device) (nvml.VgpuPgpuMetadata, nvml.Return) {
|
|
if mock.DeviceGetVgpuMetadataFunc == nil {
|
|
panic("Interface.DeviceGetVgpuMetadataFunc: method is nil but Interface.DeviceGetVgpuMetadata was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetVgpuMetadata.Lock()
|
|
mock.calls.DeviceGetVgpuMetadata = append(mock.calls.DeviceGetVgpuMetadata, callInfo)
|
|
mock.lockDeviceGetVgpuMetadata.Unlock()
|
|
return mock.DeviceGetVgpuMetadataFunc(device)
|
|
}
|
|
|
|
// DeviceGetVgpuMetadataCalls gets all the calls that were made to DeviceGetVgpuMetadata.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetVgpuMetadataCalls())
|
|
func (mock *Interface) DeviceGetVgpuMetadataCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetVgpuMetadata.RLock()
|
|
calls = mock.calls.DeviceGetVgpuMetadata
|
|
mock.lockDeviceGetVgpuMetadata.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetVgpuProcessUtilization calls DeviceGetVgpuProcessUtilizationFunc.
|
|
func (mock *Interface) DeviceGetVgpuProcessUtilization(device nvml.Device, v uint64) ([]nvml.VgpuProcessUtilizationSample, nvml.Return) {
|
|
if mock.DeviceGetVgpuProcessUtilizationFunc == nil {
|
|
panic("Interface.DeviceGetVgpuProcessUtilizationFunc: method is nil but Interface.DeviceGetVgpuProcessUtilization was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
V uint64
|
|
}{
|
|
Device: device,
|
|
V: v,
|
|
}
|
|
mock.lockDeviceGetVgpuProcessUtilization.Lock()
|
|
mock.calls.DeviceGetVgpuProcessUtilization = append(mock.calls.DeviceGetVgpuProcessUtilization, callInfo)
|
|
mock.lockDeviceGetVgpuProcessUtilization.Unlock()
|
|
return mock.DeviceGetVgpuProcessUtilizationFunc(device, v)
|
|
}
|
|
|
|
// DeviceGetVgpuProcessUtilizationCalls gets all the calls that were made to DeviceGetVgpuProcessUtilization.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetVgpuProcessUtilizationCalls())
|
|
func (mock *Interface) DeviceGetVgpuProcessUtilizationCalls() []struct {
|
|
Device nvml.Device
|
|
V uint64
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
V uint64
|
|
}
|
|
mock.lockDeviceGetVgpuProcessUtilization.RLock()
|
|
calls = mock.calls.DeviceGetVgpuProcessUtilization
|
|
mock.lockDeviceGetVgpuProcessUtilization.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetVgpuSchedulerCapabilities calls DeviceGetVgpuSchedulerCapabilitiesFunc.
|
|
func (mock *Interface) DeviceGetVgpuSchedulerCapabilities(device nvml.Device) (nvml.VgpuSchedulerCapabilities, nvml.Return) {
|
|
if mock.DeviceGetVgpuSchedulerCapabilitiesFunc == nil {
|
|
panic("Interface.DeviceGetVgpuSchedulerCapabilitiesFunc: method is nil but Interface.DeviceGetVgpuSchedulerCapabilities was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetVgpuSchedulerCapabilities.Lock()
|
|
mock.calls.DeviceGetVgpuSchedulerCapabilities = append(mock.calls.DeviceGetVgpuSchedulerCapabilities, callInfo)
|
|
mock.lockDeviceGetVgpuSchedulerCapabilities.Unlock()
|
|
return mock.DeviceGetVgpuSchedulerCapabilitiesFunc(device)
|
|
}
|
|
|
|
// DeviceGetVgpuSchedulerCapabilitiesCalls gets all the calls that were made to DeviceGetVgpuSchedulerCapabilities.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetVgpuSchedulerCapabilitiesCalls())
|
|
func (mock *Interface) DeviceGetVgpuSchedulerCapabilitiesCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetVgpuSchedulerCapabilities.RLock()
|
|
calls = mock.calls.DeviceGetVgpuSchedulerCapabilities
|
|
mock.lockDeviceGetVgpuSchedulerCapabilities.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetVgpuSchedulerLog calls DeviceGetVgpuSchedulerLogFunc.
|
|
func (mock *Interface) DeviceGetVgpuSchedulerLog(device nvml.Device) (nvml.VgpuSchedulerLog, nvml.Return) {
|
|
if mock.DeviceGetVgpuSchedulerLogFunc == nil {
|
|
panic("Interface.DeviceGetVgpuSchedulerLogFunc: method is nil but Interface.DeviceGetVgpuSchedulerLog was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetVgpuSchedulerLog.Lock()
|
|
mock.calls.DeviceGetVgpuSchedulerLog = append(mock.calls.DeviceGetVgpuSchedulerLog, callInfo)
|
|
mock.lockDeviceGetVgpuSchedulerLog.Unlock()
|
|
return mock.DeviceGetVgpuSchedulerLogFunc(device)
|
|
}
|
|
|
|
// DeviceGetVgpuSchedulerLogCalls gets all the calls that were made to DeviceGetVgpuSchedulerLog.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetVgpuSchedulerLogCalls())
|
|
func (mock *Interface) DeviceGetVgpuSchedulerLogCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetVgpuSchedulerLog.RLock()
|
|
calls = mock.calls.DeviceGetVgpuSchedulerLog
|
|
mock.lockDeviceGetVgpuSchedulerLog.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetVgpuSchedulerState calls DeviceGetVgpuSchedulerStateFunc.
|
|
func (mock *Interface) DeviceGetVgpuSchedulerState(device nvml.Device) (nvml.VgpuSchedulerGetState, nvml.Return) {
|
|
if mock.DeviceGetVgpuSchedulerStateFunc == nil {
|
|
panic("Interface.DeviceGetVgpuSchedulerStateFunc: method is nil but Interface.DeviceGetVgpuSchedulerState was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetVgpuSchedulerState.Lock()
|
|
mock.calls.DeviceGetVgpuSchedulerState = append(mock.calls.DeviceGetVgpuSchedulerState, callInfo)
|
|
mock.lockDeviceGetVgpuSchedulerState.Unlock()
|
|
return mock.DeviceGetVgpuSchedulerStateFunc(device)
|
|
}
|
|
|
|
// DeviceGetVgpuSchedulerStateCalls gets all the calls that were made to DeviceGetVgpuSchedulerState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetVgpuSchedulerStateCalls())
|
|
func (mock *Interface) DeviceGetVgpuSchedulerStateCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetVgpuSchedulerState.RLock()
|
|
calls = mock.calls.DeviceGetVgpuSchedulerState
|
|
mock.lockDeviceGetVgpuSchedulerState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetVgpuUtilization calls DeviceGetVgpuUtilizationFunc.
|
|
func (mock *Interface) DeviceGetVgpuUtilization(device nvml.Device, v uint64) (nvml.ValueType, []nvml.VgpuInstanceUtilizationSample, nvml.Return) {
|
|
if mock.DeviceGetVgpuUtilizationFunc == nil {
|
|
panic("Interface.DeviceGetVgpuUtilizationFunc: method is nil but Interface.DeviceGetVgpuUtilization was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
V uint64
|
|
}{
|
|
Device: device,
|
|
V: v,
|
|
}
|
|
mock.lockDeviceGetVgpuUtilization.Lock()
|
|
mock.calls.DeviceGetVgpuUtilization = append(mock.calls.DeviceGetVgpuUtilization, callInfo)
|
|
mock.lockDeviceGetVgpuUtilization.Unlock()
|
|
return mock.DeviceGetVgpuUtilizationFunc(device, v)
|
|
}
|
|
|
|
// DeviceGetVgpuUtilizationCalls gets all the calls that were made to DeviceGetVgpuUtilization.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetVgpuUtilizationCalls())
|
|
func (mock *Interface) DeviceGetVgpuUtilizationCalls() []struct {
|
|
Device nvml.Device
|
|
V uint64
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
V uint64
|
|
}
|
|
mock.lockDeviceGetVgpuUtilization.RLock()
|
|
calls = mock.calls.DeviceGetVgpuUtilization
|
|
mock.lockDeviceGetVgpuUtilization.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetViolationStatus calls DeviceGetViolationStatusFunc.
|
|
func (mock *Interface) DeviceGetViolationStatus(device nvml.Device, perfPolicyType nvml.PerfPolicyType) (nvml.ViolationTime, nvml.Return) {
|
|
if mock.DeviceGetViolationStatusFunc == nil {
|
|
panic("Interface.DeviceGetViolationStatusFunc: method is nil but Interface.DeviceGetViolationStatus was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
PerfPolicyType nvml.PerfPolicyType
|
|
}{
|
|
Device: device,
|
|
PerfPolicyType: perfPolicyType,
|
|
}
|
|
mock.lockDeviceGetViolationStatus.Lock()
|
|
mock.calls.DeviceGetViolationStatus = append(mock.calls.DeviceGetViolationStatus, callInfo)
|
|
mock.lockDeviceGetViolationStatus.Unlock()
|
|
return mock.DeviceGetViolationStatusFunc(device, perfPolicyType)
|
|
}
|
|
|
|
// DeviceGetViolationStatusCalls gets all the calls that were made to DeviceGetViolationStatus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetViolationStatusCalls())
|
|
func (mock *Interface) DeviceGetViolationStatusCalls() []struct {
|
|
Device nvml.Device
|
|
PerfPolicyType nvml.PerfPolicyType
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
PerfPolicyType nvml.PerfPolicyType
|
|
}
|
|
mock.lockDeviceGetViolationStatus.RLock()
|
|
calls = mock.calls.DeviceGetViolationStatus
|
|
mock.lockDeviceGetViolationStatus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceGetVirtualizationMode calls DeviceGetVirtualizationModeFunc.
|
|
func (mock *Interface) DeviceGetVirtualizationMode(device nvml.Device) (nvml.GpuVirtualizationMode, nvml.Return) {
|
|
if mock.DeviceGetVirtualizationModeFunc == nil {
|
|
panic("Interface.DeviceGetVirtualizationModeFunc: method is nil but Interface.DeviceGetVirtualizationMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceGetVirtualizationMode.Lock()
|
|
mock.calls.DeviceGetVirtualizationMode = append(mock.calls.DeviceGetVirtualizationMode, callInfo)
|
|
mock.lockDeviceGetVirtualizationMode.Unlock()
|
|
return mock.DeviceGetVirtualizationModeFunc(device)
|
|
}
|
|
|
|
// DeviceGetVirtualizationModeCalls gets all the calls that were made to DeviceGetVirtualizationMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceGetVirtualizationModeCalls())
|
|
func (mock *Interface) DeviceGetVirtualizationModeCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceGetVirtualizationMode.RLock()
|
|
calls = mock.calls.DeviceGetVirtualizationMode
|
|
mock.lockDeviceGetVirtualizationMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceIsMigDeviceHandle calls DeviceIsMigDeviceHandleFunc.
|
|
func (mock *Interface) DeviceIsMigDeviceHandle(device nvml.Device) (bool, nvml.Return) {
|
|
if mock.DeviceIsMigDeviceHandleFunc == nil {
|
|
panic("Interface.DeviceIsMigDeviceHandleFunc: method is nil but Interface.DeviceIsMigDeviceHandle was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceIsMigDeviceHandle.Lock()
|
|
mock.calls.DeviceIsMigDeviceHandle = append(mock.calls.DeviceIsMigDeviceHandle, callInfo)
|
|
mock.lockDeviceIsMigDeviceHandle.Unlock()
|
|
return mock.DeviceIsMigDeviceHandleFunc(device)
|
|
}
|
|
|
|
// DeviceIsMigDeviceHandleCalls gets all the calls that were made to DeviceIsMigDeviceHandle.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceIsMigDeviceHandleCalls())
|
|
func (mock *Interface) DeviceIsMigDeviceHandleCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceIsMigDeviceHandle.RLock()
|
|
calls = mock.calls.DeviceIsMigDeviceHandle
|
|
mock.lockDeviceIsMigDeviceHandle.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceModifyDrainState calls DeviceModifyDrainStateFunc.
|
|
func (mock *Interface) DeviceModifyDrainState(pciInfo *nvml.PciInfo, enableState nvml.EnableState) nvml.Return {
|
|
if mock.DeviceModifyDrainStateFunc == nil {
|
|
panic("Interface.DeviceModifyDrainStateFunc: method is nil but Interface.DeviceModifyDrainState was just called")
|
|
}
|
|
callInfo := struct {
|
|
PciInfo *nvml.PciInfo
|
|
EnableState nvml.EnableState
|
|
}{
|
|
PciInfo: pciInfo,
|
|
EnableState: enableState,
|
|
}
|
|
mock.lockDeviceModifyDrainState.Lock()
|
|
mock.calls.DeviceModifyDrainState = append(mock.calls.DeviceModifyDrainState, callInfo)
|
|
mock.lockDeviceModifyDrainState.Unlock()
|
|
return mock.DeviceModifyDrainStateFunc(pciInfo, enableState)
|
|
}
|
|
|
|
// DeviceModifyDrainStateCalls gets all the calls that were made to DeviceModifyDrainState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceModifyDrainStateCalls())
|
|
func (mock *Interface) DeviceModifyDrainStateCalls() []struct {
|
|
PciInfo *nvml.PciInfo
|
|
EnableState nvml.EnableState
|
|
} {
|
|
var calls []struct {
|
|
PciInfo *nvml.PciInfo
|
|
EnableState nvml.EnableState
|
|
}
|
|
mock.lockDeviceModifyDrainState.RLock()
|
|
calls = mock.calls.DeviceModifyDrainState
|
|
mock.lockDeviceModifyDrainState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceOnSameBoard calls DeviceOnSameBoardFunc.
|
|
func (mock *Interface) DeviceOnSameBoard(device1 nvml.Device, device2 nvml.Device) (int, nvml.Return) {
|
|
if mock.DeviceOnSameBoardFunc == nil {
|
|
panic("Interface.DeviceOnSameBoardFunc: method is nil but Interface.DeviceOnSameBoard was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device1 nvml.Device
|
|
Device2 nvml.Device
|
|
}{
|
|
Device1: device1,
|
|
Device2: device2,
|
|
}
|
|
mock.lockDeviceOnSameBoard.Lock()
|
|
mock.calls.DeviceOnSameBoard = append(mock.calls.DeviceOnSameBoard, callInfo)
|
|
mock.lockDeviceOnSameBoard.Unlock()
|
|
return mock.DeviceOnSameBoardFunc(device1, device2)
|
|
}
|
|
|
|
// DeviceOnSameBoardCalls gets all the calls that were made to DeviceOnSameBoard.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceOnSameBoardCalls())
|
|
func (mock *Interface) DeviceOnSameBoardCalls() []struct {
|
|
Device1 nvml.Device
|
|
Device2 nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device1 nvml.Device
|
|
Device2 nvml.Device
|
|
}
|
|
mock.lockDeviceOnSameBoard.RLock()
|
|
calls = mock.calls.DeviceOnSameBoard
|
|
mock.lockDeviceOnSameBoard.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceQueryDrainState calls DeviceQueryDrainStateFunc.
|
|
func (mock *Interface) DeviceQueryDrainState(pciInfo *nvml.PciInfo) (nvml.EnableState, nvml.Return) {
|
|
if mock.DeviceQueryDrainStateFunc == nil {
|
|
panic("Interface.DeviceQueryDrainStateFunc: method is nil but Interface.DeviceQueryDrainState was just called")
|
|
}
|
|
callInfo := struct {
|
|
PciInfo *nvml.PciInfo
|
|
}{
|
|
PciInfo: pciInfo,
|
|
}
|
|
mock.lockDeviceQueryDrainState.Lock()
|
|
mock.calls.DeviceQueryDrainState = append(mock.calls.DeviceQueryDrainState, callInfo)
|
|
mock.lockDeviceQueryDrainState.Unlock()
|
|
return mock.DeviceQueryDrainStateFunc(pciInfo)
|
|
}
|
|
|
|
// DeviceQueryDrainStateCalls gets all the calls that were made to DeviceQueryDrainState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceQueryDrainStateCalls())
|
|
func (mock *Interface) DeviceQueryDrainStateCalls() []struct {
|
|
PciInfo *nvml.PciInfo
|
|
} {
|
|
var calls []struct {
|
|
PciInfo *nvml.PciInfo
|
|
}
|
|
mock.lockDeviceQueryDrainState.RLock()
|
|
calls = mock.calls.DeviceQueryDrainState
|
|
mock.lockDeviceQueryDrainState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceRegisterEvents calls DeviceRegisterEventsFunc.
|
|
func (mock *Interface) DeviceRegisterEvents(device nvml.Device, v uint64, eventSet nvml.EventSet) nvml.Return {
|
|
if mock.DeviceRegisterEventsFunc == nil {
|
|
panic("Interface.DeviceRegisterEventsFunc: method is nil but Interface.DeviceRegisterEvents was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
V uint64
|
|
EventSet nvml.EventSet
|
|
}{
|
|
Device: device,
|
|
V: v,
|
|
EventSet: eventSet,
|
|
}
|
|
mock.lockDeviceRegisterEvents.Lock()
|
|
mock.calls.DeviceRegisterEvents = append(mock.calls.DeviceRegisterEvents, callInfo)
|
|
mock.lockDeviceRegisterEvents.Unlock()
|
|
return mock.DeviceRegisterEventsFunc(device, v, eventSet)
|
|
}
|
|
|
|
// DeviceRegisterEventsCalls gets all the calls that were made to DeviceRegisterEvents.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceRegisterEventsCalls())
|
|
func (mock *Interface) DeviceRegisterEventsCalls() []struct {
|
|
Device nvml.Device
|
|
V uint64
|
|
EventSet nvml.EventSet
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
V uint64
|
|
EventSet nvml.EventSet
|
|
}
|
|
mock.lockDeviceRegisterEvents.RLock()
|
|
calls = mock.calls.DeviceRegisterEvents
|
|
mock.lockDeviceRegisterEvents.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceRemoveGpu calls DeviceRemoveGpuFunc.
|
|
func (mock *Interface) DeviceRemoveGpu(pciInfo *nvml.PciInfo) nvml.Return {
|
|
if mock.DeviceRemoveGpuFunc == nil {
|
|
panic("Interface.DeviceRemoveGpuFunc: method is nil but Interface.DeviceRemoveGpu was just called")
|
|
}
|
|
callInfo := struct {
|
|
PciInfo *nvml.PciInfo
|
|
}{
|
|
PciInfo: pciInfo,
|
|
}
|
|
mock.lockDeviceRemoveGpu.Lock()
|
|
mock.calls.DeviceRemoveGpu = append(mock.calls.DeviceRemoveGpu, callInfo)
|
|
mock.lockDeviceRemoveGpu.Unlock()
|
|
return mock.DeviceRemoveGpuFunc(pciInfo)
|
|
}
|
|
|
|
// DeviceRemoveGpuCalls gets all the calls that were made to DeviceRemoveGpu.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceRemoveGpuCalls())
|
|
func (mock *Interface) DeviceRemoveGpuCalls() []struct {
|
|
PciInfo *nvml.PciInfo
|
|
} {
|
|
var calls []struct {
|
|
PciInfo *nvml.PciInfo
|
|
}
|
|
mock.lockDeviceRemoveGpu.RLock()
|
|
calls = mock.calls.DeviceRemoveGpu
|
|
mock.lockDeviceRemoveGpu.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceRemoveGpu_v2 calls DeviceRemoveGpu_v2Func.
|
|
func (mock *Interface) DeviceRemoveGpu_v2(pciInfo *nvml.PciInfo, detachGpuState nvml.DetachGpuState, pcieLinkState nvml.PcieLinkState) nvml.Return {
|
|
if mock.DeviceRemoveGpu_v2Func == nil {
|
|
panic("Interface.DeviceRemoveGpu_v2Func: method is nil but Interface.DeviceRemoveGpu_v2 was just called")
|
|
}
|
|
callInfo := struct {
|
|
PciInfo *nvml.PciInfo
|
|
DetachGpuState nvml.DetachGpuState
|
|
PcieLinkState nvml.PcieLinkState
|
|
}{
|
|
PciInfo: pciInfo,
|
|
DetachGpuState: detachGpuState,
|
|
PcieLinkState: pcieLinkState,
|
|
}
|
|
mock.lockDeviceRemoveGpu_v2.Lock()
|
|
mock.calls.DeviceRemoveGpu_v2 = append(mock.calls.DeviceRemoveGpu_v2, callInfo)
|
|
mock.lockDeviceRemoveGpu_v2.Unlock()
|
|
return mock.DeviceRemoveGpu_v2Func(pciInfo, detachGpuState, pcieLinkState)
|
|
}
|
|
|
|
// DeviceRemoveGpu_v2Calls gets all the calls that were made to DeviceRemoveGpu_v2.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceRemoveGpu_v2Calls())
|
|
func (mock *Interface) DeviceRemoveGpu_v2Calls() []struct {
|
|
PciInfo *nvml.PciInfo
|
|
DetachGpuState nvml.DetachGpuState
|
|
PcieLinkState nvml.PcieLinkState
|
|
} {
|
|
var calls []struct {
|
|
PciInfo *nvml.PciInfo
|
|
DetachGpuState nvml.DetachGpuState
|
|
PcieLinkState nvml.PcieLinkState
|
|
}
|
|
mock.lockDeviceRemoveGpu_v2.RLock()
|
|
calls = mock.calls.DeviceRemoveGpu_v2
|
|
mock.lockDeviceRemoveGpu_v2.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceResetApplicationsClocks calls DeviceResetApplicationsClocksFunc.
|
|
func (mock *Interface) DeviceResetApplicationsClocks(device nvml.Device) nvml.Return {
|
|
if mock.DeviceResetApplicationsClocksFunc == nil {
|
|
panic("Interface.DeviceResetApplicationsClocksFunc: method is nil but Interface.DeviceResetApplicationsClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceResetApplicationsClocks.Lock()
|
|
mock.calls.DeviceResetApplicationsClocks = append(mock.calls.DeviceResetApplicationsClocks, callInfo)
|
|
mock.lockDeviceResetApplicationsClocks.Unlock()
|
|
return mock.DeviceResetApplicationsClocksFunc(device)
|
|
}
|
|
|
|
// DeviceResetApplicationsClocksCalls gets all the calls that were made to DeviceResetApplicationsClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceResetApplicationsClocksCalls())
|
|
func (mock *Interface) DeviceResetApplicationsClocksCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceResetApplicationsClocks.RLock()
|
|
calls = mock.calls.DeviceResetApplicationsClocks
|
|
mock.lockDeviceResetApplicationsClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceResetGpuLockedClocks calls DeviceResetGpuLockedClocksFunc.
|
|
func (mock *Interface) DeviceResetGpuLockedClocks(device nvml.Device) nvml.Return {
|
|
if mock.DeviceResetGpuLockedClocksFunc == nil {
|
|
panic("Interface.DeviceResetGpuLockedClocksFunc: method is nil but Interface.DeviceResetGpuLockedClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceResetGpuLockedClocks.Lock()
|
|
mock.calls.DeviceResetGpuLockedClocks = append(mock.calls.DeviceResetGpuLockedClocks, callInfo)
|
|
mock.lockDeviceResetGpuLockedClocks.Unlock()
|
|
return mock.DeviceResetGpuLockedClocksFunc(device)
|
|
}
|
|
|
|
// DeviceResetGpuLockedClocksCalls gets all the calls that were made to DeviceResetGpuLockedClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceResetGpuLockedClocksCalls())
|
|
func (mock *Interface) DeviceResetGpuLockedClocksCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceResetGpuLockedClocks.RLock()
|
|
calls = mock.calls.DeviceResetGpuLockedClocks
|
|
mock.lockDeviceResetGpuLockedClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceResetMemoryLockedClocks calls DeviceResetMemoryLockedClocksFunc.
|
|
func (mock *Interface) DeviceResetMemoryLockedClocks(device nvml.Device) nvml.Return {
|
|
if mock.DeviceResetMemoryLockedClocksFunc == nil {
|
|
panic("Interface.DeviceResetMemoryLockedClocksFunc: method is nil but Interface.DeviceResetMemoryLockedClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceResetMemoryLockedClocks.Lock()
|
|
mock.calls.DeviceResetMemoryLockedClocks = append(mock.calls.DeviceResetMemoryLockedClocks, callInfo)
|
|
mock.lockDeviceResetMemoryLockedClocks.Unlock()
|
|
return mock.DeviceResetMemoryLockedClocksFunc(device)
|
|
}
|
|
|
|
// DeviceResetMemoryLockedClocksCalls gets all the calls that were made to DeviceResetMemoryLockedClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceResetMemoryLockedClocksCalls())
|
|
func (mock *Interface) DeviceResetMemoryLockedClocksCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceResetMemoryLockedClocks.RLock()
|
|
calls = mock.calls.DeviceResetMemoryLockedClocks
|
|
mock.lockDeviceResetMemoryLockedClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceResetNvLinkErrorCounters calls DeviceResetNvLinkErrorCountersFunc.
|
|
func (mock *Interface) DeviceResetNvLinkErrorCounters(device nvml.Device, n int) nvml.Return {
|
|
if mock.DeviceResetNvLinkErrorCountersFunc == nil {
|
|
panic("Interface.DeviceResetNvLinkErrorCountersFunc: method is nil but Interface.DeviceResetNvLinkErrorCounters was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceResetNvLinkErrorCounters.Lock()
|
|
mock.calls.DeviceResetNvLinkErrorCounters = append(mock.calls.DeviceResetNvLinkErrorCounters, callInfo)
|
|
mock.lockDeviceResetNvLinkErrorCounters.Unlock()
|
|
return mock.DeviceResetNvLinkErrorCountersFunc(device, n)
|
|
}
|
|
|
|
// DeviceResetNvLinkErrorCountersCalls gets all the calls that were made to DeviceResetNvLinkErrorCounters.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceResetNvLinkErrorCountersCalls())
|
|
func (mock *Interface) DeviceResetNvLinkErrorCountersCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceResetNvLinkErrorCounters.RLock()
|
|
calls = mock.calls.DeviceResetNvLinkErrorCounters
|
|
mock.lockDeviceResetNvLinkErrorCounters.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceResetNvLinkUtilizationCounter calls DeviceResetNvLinkUtilizationCounterFunc.
|
|
func (mock *Interface) DeviceResetNvLinkUtilizationCounter(device nvml.Device, n1 int, n2 int) nvml.Return {
|
|
if mock.DeviceResetNvLinkUtilizationCounterFunc == nil {
|
|
panic("Interface.DeviceResetNvLinkUtilizationCounterFunc: method is nil but Interface.DeviceResetNvLinkUtilizationCounter was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
}{
|
|
Device: device,
|
|
N1: n1,
|
|
N2: n2,
|
|
}
|
|
mock.lockDeviceResetNvLinkUtilizationCounter.Lock()
|
|
mock.calls.DeviceResetNvLinkUtilizationCounter = append(mock.calls.DeviceResetNvLinkUtilizationCounter, callInfo)
|
|
mock.lockDeviceResetNvLinkUtilizationCounter.Unlock()
|
|
return mock.DeviceResetNvLinkUtilizationCounterFunc(device, n1, n2)
|
|
}
|
|
|
|
// DeviceResetNvLinkUtilizationCounterCalls gets all the calls that were made to DeviceResetNvLinkUtilizationCounter.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceResetNvLinkUtilizationCounterCalls())
|
|
func (mock *Interface) DeviceResetNvLinkUtilizationCounterCalls() []struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
}
|
|
mock.lockDeviceResetNvLinkUtilizationCounter.RLock()
|
|
calls = mock.calls.DeviceResetNvLinkUtilizationCounter
|
|
mock.lockDeviceResetNvLinkUtilizationCounter.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetAPIRestriction calls DeviceSetAPIRestrictionFunc.
|
|
func (mock *Interface) DeviceSetAPIRestriction(device nvml.Device, restrictedAPI nvml.RestrictedAPI, enableState nvml.EnableState) nvml.Return {
|
|
if mock.DeviceSetAPIRestrictionFunc == nil {
|
|
panic("Interface.DeviceSetAPIRestrictionFunc: method is nil but Interface.DeviceSetAPIRestriction was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
EnableState nvml.EnableState
|
|
}{
|
|
Device: device,
|
|
RestrictedAPI: restrictedAPI,
|
|
EnableState: enableState,
|
|
}
|
|
mock.lockDeviceSetAPIRestriction.Lock()
|
|
mock.calls.DeviceSetAPIRestriction = append(mock.calls.DeviceSetAPIRestriction, callInfo)
|
|
mock.lockDeviceSetAPIRestriction.Unlock()
|
|
return mock.DeviceSetAPIRestrictionFunc(device, restrictedAPI, enableState)
|
|
}
|
|
|
|
// DeviceSetAPIRestrictionCalls gets all the calls that were made to DeviceSetAPIRestriction.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetAPIRestrictionCalls())
|
|
func (mock *Interface) DeviceSetAPIRestrictionCalls() []struct {
|
|
Device nvml.Device
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
EnableState nvml.EnableState
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
EnableState nvml.EnableState
|
|
}
|
|
mock.lockDeviceSetAPIRestriction.RLock()
|
|
calls = mock.calls.DeviceSetAPIRestriction
|
|
mock.lockDeviceSetAPIRestriction.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetAccountingMode calls DeviceSetAccountingModeFunc.
|
|
func (mock *Interface) DeviceSetAccountingMode(device nvml.Device, enableState nvml.EnableState) nvml.Return {
|
|
if mock.DeviceSetAccountingModeFunc == nil {
|
|
panic("Interface.DeviceSetAccountingModeFunc: method is nil but Interface.DeviceSetAccountingMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
}{
|
|
Device: device,
|
|
EnableState: enableState,
|
|
}
|
|
mock.lockDeviceSetAccountingMode.Lock()
|
|
mock.calls.DeviceSetAccountingMode = append(mock.calls.DeviceSetAccountingMode, callInfo)
|
|
mock.lockDeviceSetAccountingMode.Unlock()
|
|
return mock.DeviceSetAccountingModeFunc(device, enableState)
|
|
}
|
|
|
|
// DeviceSetAccountingModeCalls gets all the calls that were made to DeviceSetAccountingMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetAccountingModeCalls())
|
|
func (mock *Interface) DeviceSetAccountingModeCalls() []struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
}
|
|
mock.lockDeviceSetAccountingMode.RLock()
|
|
calls = mock.calls.DeviceSetAccountingMode
|
|
mock.lockDeviceSetAccountingMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetApplicationsClocks calls DeviceSetApplicationsClocksFunc.
|
|
func (mock *Interface) DeviceSetApplicationsClocks(device nvml.Device, v1 uint32, v2 uint32) nvml.Return {
|
|
if mock.DeviceSetApplicationsClocksFunc == nil {
|
|
panic("Interface.DeviceSetApplicationsClocksFunc: method is nil but Interface.DeviceSetApplicationsClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
V1 uint32
|
|
V2 uint32
|
|
}{
|
|
Device: device,
|
|
V1: v1,
|
|
V2: v2,
|
|
}
|
|
mock.lockDeviceSetApplicationsClocks.Lock()
|
|
mock.calls.DeviceSetApplicationsClocks = append(mock.calls.DeviceSetApplicationsClocks, callInfo)
|
|
mock.lockDeviceSetApplicationsClocks.Unlock()
|
|
return mock.DeviceSetApplicationsClocksFunc(device, v1, v2)
|
|
}
|
|
|
|
// DeviceSetApplicationsClocksCalls gets all the calls that were made to DeviceSetApplicationsClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetApplicationsClocksCalls())
|
|
func (mock *Interface) DeviceSetApplicationsClocksCalls() []struct {
|
|
Device nvml.Device
|
|
V1 uint32
|
|
V2 uint32
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
V1 uint32
|
|
V2 uint32
|
|
}
|
|
mock.lockDeviceSetApplicationsClocks.RLock()
|
|
calls = mock.calls.DeviceSetApplicationsClocks
|
|
mock.lockDeviceSetApplicationsClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetAutoBoostedClocksEnabled calls DeviceSetAutoBoostedClocksEnabledFunc.
|
|
func (mock *Interface) DeviceSetAutoBoostedClocksEnabled(device nvml.Device, enableState nvml.EnableState) nvml.Return {
|
|
if mock.DeviceSetAutoBoostedClocksEnabledFunc == nil {
|
|
panic("Interface.DeviceSetAutoBoostedClocksEnabledFunc: method is nil but Interface.DeviceSetAutoBoostedClocksEnabled was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
}{
|
|
Device: device,
|
|
EnableState: enableState,
|
|
}
|
|
mock.lockDeviceSetAutoBoostedClocksEnabled.Lock()
|
|
mock.calls.DeviceSetAutoBoostedClocksEnabled = append(mock.calls.DeviceSetAutoBoostedClocksEnabled, callInfo)
|
|
mock.lockDeviceSetAutoBoostedClocksEnabled.Unlock()
|
|
return mock.DeviceSetAutoBoostedClocksEnabledFunc(device, enableState)
|
|
}
|
|
|
|
// DeviceSetAutoBoostedClocksEnabledCalls gets all the calls that were made to DeviceSetAutoBoostedClocksEnabled.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetAutoBoostedClocksEnabledCalls())
|
|
func (mock *Interface) DeviceSetAutoBoostedClocksEnabledCalls() []struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
}
|
|
mock.lockDeviceSetAutoBoostedClocksEnabled.RLock()
|
|
calls = mock.calls.DeviceSetAutoBoostedClocksEnabled
|
|
mock.lockDeviceSetAutoBoostedClocksEnabled.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetComputeMode calls DeviceSetComputeModeFunc.
|
|
func (mock *Interface) DeviceSetComputeMode(device nvml.Device, computeMode nvml.ComputeMode) nvml.Return {
|
|
if mock.DeviceSetComputeModeFunc == nil {
|
|
panic("Interface.DeviceSetComputeModeFunc: method is nil but Interface.DeviceSetComputeMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
ComputeMode nvml.ComputeMode
|
|
}{
|
|
Device: device,
|
|
ComputeMode: computeMode,
|
|
}
|
|
mock.lockDeviceSetComputeMode.Lock()
|
|
mock.calls.DeviceSetComputeMode = append(mock.calls.DeviceSetComputeMode, callInfo)
|
|
mock.lockDeviceSetComputeMode.Unlock()
|
|
return mock.DeviceSetComputeModeFunc(device, computeMode)
|
|
}
|
|
|
|
// DeviceSetComputeModeCalls gets all the calls that were made to DeviceSetComputeMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetComputeModeCalls())
|
|
func (mock *Interface) DeviceSetComputeModeCalls() []struct {
|
|
Device nvml.Device
|
|
ComputeMode nvml.ComputeMode
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
ComputeMode nvml.ComputeMode
|
|
}
|
|
mock.lockDeviceSetComputeMode.RLock()
|
|
calls = mock.calls.DeviceSetComputeMode
|
|
mock.lockDeviceSetComputeMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetCpuAffinity calls DeviceSetCpuAffinityFunc.
|
|
func (mock *Interface) DeviceSetCpuAffinity(device nvml.Device) nvml.Return {
|
|
if mock.DeviceSetCpuAffinityFunc == nil {
|
|
panic("Interface.DeviceSetCpuAffinityFunc: method is nil but Interface.DeviceSetCpuAffinity was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceSetCpuAffinity.Lock()
|
|
mock.calls.DeviceSetCpuAffinity = append(mock.calls.DeviceSetCpuAffinity, callInfo)
|
|
mock.lockDeviceSetCpuAffinity.Unlock()
|
|
return mock.DeviceSetCpuAffinityFunc(device)
|
|
}
|
|
|
|
// DeviceSetCpuAffinityCalls gets all the calls that were made to DeviceSetCpuAffinity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetCpuAffinityCalls())
|
|
func (mock *Interface) DeviceSetCpuAffinityCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceSetCpuAffinity.RLock()
|
|
calls = mock.calls.DeviceSetCpuAffinity
|
|
mock.lockDeviceSetCpuAffinity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetDefaultAutoBoostedClocksEnabled calls DeviceSetDefaultAutoBoostedClocksEnabledFunc.
|
|
func (mock *Interface) DeviceSetDefaultAutoBoostedClocksEnabled(device nvml.Device, enableState nvml.EnableState, v uint32) nvml.Return {
|
|
if mock.DeviceSetDefaultAutoBoostedClocksEnabledFunc == nil {
|
|
panic("Interface.DeviceSetDefaultAutoBoostedClocksEnabledFunc: method is nil but Interface.DeviceSetDefaultAutoBoostedClocksEnabled was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
V uint32
|
|
}{
|
|
Device: device,
|
|
EnableState: enableState,
|
|
V: v,
|
|
}
|
|
mock.lockDeviceSetDefaultAutoBoostedClocksEnabled.Lock()
|
|
mock.calls.DeviceSetDefaultAutoBoostedClocksEnabled = append(mock.calls.DeviceSetDefaultAutoBoostedClocksEnabled, callInfo)
|
|
mock.lockDeviceSetDefaultAutoBoostedClocksEnabled.Unlock()
|
|
return mock.DeviceSetDefaultAutoBoostedClocksEnabledFunc(device, enableState, v)
|
|
}
|
|
|
|
// DeviceSetDefaultAutoBoostedClocksEnabledCalls gets all the calls that were made to DeviceSetDefaultAutoBoostedClocksEnabled.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetDefaultAutoBoostedClocksEnabledCalls())
|
|
func (mock *Interface) DeviceSetDefaultAutoBoostedClocksEnabledCalls() []struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
V uint32
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
V uint32
|
|
}
|
|
mock.lockDeviceSetDefaultAutoBoostedClocksEnabled.RLock()
|
|
calls = mock.calls.DeviceSetDefaultAutoBoostedClocksEnabled
|
|
mock.lockDeviceSetDefaultAutoBoostedClocksEnabled.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetDefaultFanSpeed_v2 calls DeviceSetDefaultFanSpeed_v2Func.
|
|
func (mock *Interface) DeviceSetDefaultFanSpeed_v2(device nvml.Device, n int) nvml.Return {
|
|
if mock.DeviceSetDefaultFanSpeed_v2Func == nil {
|
|
panic("Interface.DeviceSetDefaultFanSpeed_v2Func: method is nil but Interface.DeviceSetDefaultFanSpeed_v2 was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceSetDefaultFanSpeed_v2.Lock()
|
|
mock.calls.DeviceSetDefaultFanSpeed_v2 = append(mock.calls.DeviceSetDefaultFanSpeed_v2, callInfo)
|
|
mock.lockDeviceSetDefaultFanSpeed_v2.Unlock()
|
|
return mock.DeviceSetDefaultFanSpeed_v2Func(device, n)
|
|
}
|
|
|
|
// DeviceSetDefaultFanSpeed_v2Calls gets all the calls that were made to DeviceSetDefaultFanSpeed_v2.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetDefaultFanSpeed_v2Calls())
|
|
func (mock *Interface) DeviceSetDefaultFanSpeed_v2Calls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceSetDefaultFanSpeed_v2.RLock()
|
|
calls = mock.calls.DeviceSetDefaultFanSpeed_v2
|
|
mock.lockDeviceSetDefaultFanSpeed_v2.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetDriverModel calls DeviceSetDriverModelFunc.
|
|
func (mock *Interface) DeviceSetDriverModel(device nvml.Device, driverModel nvml.DriverModel, v uint32) nvml.Return {
|
|
if mock.DeviceSetDriverModelFunc == nil {
|
|
panic("Interface.DeviceSetDriverModelFunc: method is nil but Interface.DeviceSetDriverModel was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
DriverModel nvml.DriverModel
|
|
V uint32
|
|
}{
|
|
Device: device,
|
|
DriverModel: driverModel,
|
|
V: v,
|
|
}
|
|
mock.lockDeviceSetDriverModel.Lock()
|
|
mock.calls.DeviceSetDriverModel = append(mock.calls.DeviceSetDriverModel, callInfo)
|
|
mock.lockDeviceSetDriverModel.Unlock()
|
|
return mock.DeviceSetDriverModelFunc(device, driverModel, v)
|
|
}
|
|
|
|
// DeviceSetDriverModelCalls gets all the calls that were made to DeviceSetDriverModel.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetDriverModelCalls())
|
|
func (mock *Interface) DeviceSetDriverModelCalls() []struct {
|
|
Device nvml.Device
|
|
DriverModel nvml.DriverModel
|
|
V uint32
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
DriverModel nvml.DriverModel
|
|
V uint32
|
|
}
|
|
mock.lockDeviceSetDriverModel.RLock()
|
|
calls = mock.calls.DeviceSetDriverModel
|
|
mock.lockDeviceSetDriverModel.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetEccMode calls DeviceSetEccModeFunc.
|
|
func (mock *Interface) DeviceSetEccMode(device nvml.Device, enableState nvml.EnableState) nvml.Return {
|
|
if mock.DeviceSetEccModeFunc == nil {
|
|
panic("Interface.DeviceSetEccModeFunc: method is nil but Interface.DeviceSetEccMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
}{
|
|
Device: device,
|
|
EnableState: enableState,
|
|
}
|
|
mock.lockDeviceSetEccMode.Lock()
|
|
mock.calls.DeviceSetEccMode = append(mock.calls.DeviceSetEccMode, callInfo)
|
|
mock.lockDeviceSetEccMode.Unlock()
|
|
return mock.DeviceSetEccModeFunc(device, enableState)
|
|
}
|
|
|
|
// DeviceSetEccModeCalls gets all the calls that were made to DeviceSetEccMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetEccModeCalls())
|
|
func (mock *Interface) DeviceSetEccModeCalls() []struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
}
|
|
mock.lockDeviceSetEccMode.RLock()
|
|
calls = mock.calls.DeviceSetEccMode
|
|
mock.lockDeviceSetEccMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetFanControlPolicy calls DeviceSetFanControlPolicyFunc.
|
|
func (mock *Interface) DeviceSetFanControlPolicy(device nvml.Device, n int, fanControlPolicy nvml.FanControlPolicy) nvml.Return {
|
|
if mock.DeviceSetFanControlPolicyFunc == nil {
|
|
panic("Interface.DeviceSetFanControlPolicyFunc: method is nil but Interface.DeviceSetFanControlPolicy was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
FanControlPolicy nvml.FanControlPolicy
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
FanControlPolicy: fanControlPolicy,
|
|
}
|
|
mock.lockDeviceSetFanControlPolicy.Lock()
|
|
mock.calls.DeviceSetFanControlPolicy = append(mock.calls.DeviceSetFanControlPolicy, callInfo)
|
|
mock.lockDeviceSetFanControlPolicy.Unlock()
|
|
return mock.DeviceSetFanControlPolicyFunc(device, n, fanControlPolicy)
|
|
}
|
|
|
|
// DeviceSetFanControlPolicyCalls gets all the calls that were made to DeviceSetFanControlPolicy.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetFanControlPolicyCalls())
|
|
func (mock *Interface) DeviceSetFanControlPolicyCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
FanControlPolicy nvml.FanControlPolicy
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
FanControlPolicy nvml.FanControlPolicy
|
|
}
|
|
mock.lockDeviceSetFanControlPolicy.RLock()
|
|
calls = mock.calls.DeviceSetFanControlPolicy
|
|
mock.lockDeviceSetFanControlPolicy.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetFanSpeed_v2 calls DeviceSetFanSpeed_v2Func.
|
|
func (mock *Interface) DeviceSetFanSpeed_v2(device nvml.Device, n1 int, n2 int) nvml.Return {
|
|
if mock.DeviceSetFanSpeed_v2Func == nil {
|
|
panic("Interface.DeviceSetFanSpeed_v2Func: method is nil but Interface.DeviceSetFanSpeed_v2 was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
}{
|
|
Device: device,
|
|
N1: n1,
|
|
N2: n2,
|
|
}
|
|
mock.lockDeviceSetFanSpeed_v2.Lock()
|
|
mock.calls.DeviceSetFanSpeed_v2 = append(mock.calls.DeviceSetFanSpeed_v2, callInfo)
|
|
mock.lockDeviceSetFanSpeed_v2.Unlock()
|
|
return mock.DeviceSetFanSpeed_v2Func(device, n1, n2)
|
|
}
|
|
|
|
// DeviceSetFanSpeed_v2Calls gets all the calls that were made to DeviceSetFanSpeed_v2.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetFanSpeed_v2Calls())
|
|
func (mock *Interface) DeviceSetFanSpeed_v2Calls() []struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
}
|
|
mock.lockDeviceSetFanSpeed_v2.RLock()
|
|
calls = mock.calls.DeviceSetFanSpeed_v2
|
|
mock.lockDeviceSetFanSpeed_v2.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetGpcClkVfOffset calls DeviceSetGpcClkVfOffsetFunc.
|
|
func (mock *Interface) DeviceSetGpcClkVfOffset(device nvml.Device, n int) nvml.Return {
|
|
if mock.DeviceSetGpcClkVfOffsetFunc == nil {
|
|
panic("Interface.DeviceSetGpcClkVfOffsetFunc: method is nil but Interface.DeviceSetGpcClkVfOffset was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceSetGpcClkVfOffset.Lock()
|
|
mock.calls.DeviceSetGpcClkVfOffset = append(mock.calls.DeviceSetGpcClkVfOffset, callInfo)
|
|
mock.lockDeviceSetGpcClkVfOffset.Unlock()
|
|
return mock.DeviceSetGpcClkVfOffsetFunc(device, n)
|
|
}
|
|
|
|
// DeviceSetGpcClkVfOffsetCalls gets all the calls that were made to DeviceSetGpcClkVfOffset.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetGpcClkVfOffsetCalls())
|
|
func (mock *Interface) DeviceSetGpcClkVfOffsetCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceSetGpcClkVfOffset.RLock()
|
|
calls = mock.calls.DeviceSetGpcClkVfOffset
|
|
mock.lockDeviceSetGpcClkVfOffset.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetGpuLockedClocks calls DeviceSetGpuLockedClocksFunc.
|
|
func (mock *Interface) DeviceSetGpuLockedClocks(device nvml.Device, v1 uint32, v2 uint32) nvml.Return {
|
|
if mock.DeviceSetGpuLockedClocksFunc == nil {
|
|
panic("Interface.DeviceSetGpuLockedClocksFunc: method is nil but Interface.DeviceSetGpuLockedClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
V1 uint32
|
|
V2 uint32
|
|
}{
|
|
Device: device,
|
|
V1: v1,
|
|
V2: v2,
|
|
}
|
|
mock.lockDeviceSetGpuLockedClocks.Lock()
|
|
mock.calls.DeviceSetGpuLockedClocks = append(mock.calls.DeviceSetGpuLockedClocks, callInfo)
|
|
mock.lockDeviceSetGpuLockedClocks.Unlock()
|
|
return mock.DeviceSetGpuLockedClocksFunc(device, v1, v2)
|
|
}
|
|
|
|
// DeviceSetGpuLockedClocksCalls gets all the calls that were made to DeviceSetGpuLockedClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetGpuLockedClocksCalls())
|
|
func (mock *Interface) DeviceSetGpuLockedClocksCalls() []struct {
|
|
Device nvml.Device
|
|
V1 uint32
|
|
V2 uint32
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
V1 uint32
|
|
V2 uint32
|
|
}
|
|
mock.lockDeviceSetGpuLockedClocks.RLock()
|
|
calls = mock.calls.DeviceSetGpuLockedClocks
|
|
mock.lockDeviceSetGpuLockedClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetGpuOperationMode calls DeviceSetGpuOperationModeFunc.
|
|
func (mock *Interface) DeviceSetGpuOperationMode(device nvml.Device, gpuOperationMode nvml.GpuOperationMode) nvml.Return {
|
|
if mock.DeviceSetGpuOperationModeFunc == nil {
|
|
panic("Interface.DeviceSetGpuOperationModeFunc: method is nil but Interface.DeviceSetGpuOperationMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
GpuOperationMode nvml.GpuOperationMode
|
|
}{
|
|
Device: device,
|
|
GpuOperationMode: gpuOperationMode,
|
|
}
|
|
mock.lockDeviceSetGpuOperationMode.Lock()
|
|
mock.calls.DeviceSetGpuOperationMode = append(mock.calls.DeviceSetGpuOperationMode, callInfo)
|
|
mock.lockDeviceSetGpuOperationMode.Unlock()
|
|
return mock.DeviceSetGpuOperationModeFunc(device, gpuOperationMode)
|
|
}
|
|
|
|
// DeviceSetGpuOperationModeCalls gets all the calls that were made to DeviceSetGpuOperationMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetGpuOperationModeCalls())
|
|
func (mock *Interface) DeviceSetGpuOperationModeCalls() []struct {
|
|
Device nvml.Device
|
|
GpuOperationMode nvml.GpuOperationMode
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
GpuOperationMode nvml.GpuOperationMode
|
|
}
|
|
mock.lockDeviceSetGpuOperationMode.RLock()
|
|
calls = mock.calls.DeviceSetGpuOperationMode
|
|
mock.lockDeviceSetGpuOperationMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetMemClkVfOffset calls DeviceSetMemClkVfOffsetFunc.
|
|
func (mock *Interface) DeviceSetMemClkVfOffset(device nvml.Device, n int) nvml.Return {
|
|
if mock.DeviceSetMemClkVfOffsetFunc == nil {
|
|
panic("Interface.DeviceSetMemClkVfOffsetFunc: method is nil but Interface.DeviceSetMemClkVfOffset was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceSetMemClkVfOffset.Lock()
|
|
mock.calls.DeviceSetMemClkVfOffset = append(mock.calls.DeviceSetMemClkVfOffset, callInfo)
|
|
mock.lockDeviceSetMemClkVfOffset.Unlock()
|
|
return mock.DeviceSetMemClkVfOffsetFunc(device, n)
|
|
}
|
|
|
|
// DeviceSetMemClkVfOffsetCalls gets all the calls that were made to DeviceSetMemClkVfOffset.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetMemClkVfOffsetCalls())
|
|
func (mock *Interface) DeviceSetMemClkVfOffsetCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceSetMemClkVfOffset.RLock()
|
|
calls = mock.calls.DeviceSetMemClkVfOffset
|
|
mock.lockDeviceSetMemClkVfOffset.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetMemoryLockedClocks calls DeviceSetMemoryLockedClocksFunc.
|
|
func (mock *Interface) DeviceSetMemoryLockedClocks(device nvml.Device, v1 uint32, v2 uint32) nvml.Return {
|
|
if mock.DeviceSetMemoryLockedClocksFunc == nil {
|
|
panic("Interface.DeviceSetMemoryLockedClocksFunc: method is nil but Interface.DeviceSetMemoryLockedClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
V1 uint32
|
|
V2 uint32
|
|
}{
|
|
Device: device,
|
|
V1: v1,
|
|
V2: v2,
|
|
}
|
|
mock.lockDeviceSetMemoryLockedClocks.Lock()
|
|
mock.calls.DeviceSetMemoryLockedClocks = append(mock.calls.DeviceSetMemoryLockedClocks, callInfo)
|
|
mock.lockDeviceSetMemoryLockedClocks.Unlock()
|
|
return mock.DeviceSetMemoryLockedClocksFunc(device, v1, v2)
|
|
}
|
|
|
|
// DeviceSetMemoryLockedClocksCalls gets all the calls that were made to DeviceSetMemoryLockedClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetMemoryLockedClocksCalls())
|
|
func (mock *Interface) DeviceSetMemoryLockedClocksCalls() []struct {
|
|
Device nvml.Device
|
|
V1 uint32
|
|
V2 uint32
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
V1 uint32
|
|
V2 uint32
|
|
}
|
|
mock.lockDeviceSetMemoryLockedClocks.RLock()
|
|
calls = mock.calls.DeviceSetMemoryLockedClocks
|
|
mock.lockDeviceSetMemoryLockedClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetMigMode calls DeviceSetMigModeFunc.
|
|
func (mock *Interface) DeviceSetMigMode(device nvml.Device, n int) (nvml.Return, nvml.Return) {
|
|
if mock.DeviceSetMigModeFunc == nil {
|
|
panic("Interface.DeviceSetMigModeFunc: method is nil but Interface.DeviceSetMigMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceSetMigMode.Lock()
|
|
mock.calls.DeviceSetMigMode = append(mock.calls.DeviceSetMigMode, callInfo)
|
|
mock.lockDeviceSetMigMode.Unlock()
|
|
return mock.DeviceSetMigModeFunc(device, n)
|
|
}
|
|
|
|
// DeviceSetMigModeCalls gets all the calls that were made to DeviceSetMigMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetMigModeCalls())
|
|
func (mock *Interface) DeviceSetMigModeCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
}
|
|
mock.lockDeviceSetMigMode.RLock()
|
|
calls = mock.calls.DeviceSetMigMode
|
|
mock.lockDeviceSetMigMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetNvLinkDeviceLowPowerThreshold calls DeviceSetNvLinkDeviceLowPowerThresholdFunc.
|
|
func (mock *Interface) DeviceSetNvLinkDeviceLowPowerThreshold(device nvml.Device, nvLinkPowerThres *nvml.NvLinkPowerThres) nvml.Return {
|
|
if mock.DeviceSetNvLinkDeviceLowPowerThresholdFunc == nil {
|
|
panic("Interface.DeviceSetNvLinkDeviceLowPowerThresholdFunc: method is nil but Interface.DeviceSetNvLinkDeviceLowPowerThreshold was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
NvLinkPowerThres *nvml.NvLinkPowerThres
|
|
}{
|
|
Device: device,
|
|
NvLinkPowerThres: nvLinkPowerThres,
|
|
}
|
|
mock.lockDeviceSetNvLinkDeviceLowPowerThreshold.Lock()
|
|
mock.calls.DeviceSetNvLinkDeviceLowPowerThreshold = append(mock.calls.DeviceSetNvLinkDeviceLowPowerThreshold, callInfo)
|
|
mock.lockDeviceSetNvLinkDeviceLowPowerThreshold.Unlock()
|
|
return mock.DeviceSetNvLinkDeviceLowPowerThresholdFunc(device, nvLinkPowerThres)
|
|
}
|
|
|
|
// DeviceSetNvLinkDeviceLowPowerThresholdCalls gets all the calls that were made to DeviceSetNvLinkDeviceLowPowerThreshold.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetNvLinkDeviceLowPowerThresholdCalls())
|
|
func (mock *Interface) DeviceSetNvLinkDeviceLowPowerThresholdCalls() []struct {
|
|
Device nvml.Device
|
|
NvLinkPowerThres *nvml.NvLinkPowerThres
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
NvLinkPowerThres *nvml.NvLinkPowerThres
|
|
}
|
|
mock.lockDeviceSetNvLinkDeviceLowPowerThreshold.RLock()
|
|
calls = mock.calls.DeviceSetNvLinkDeviceLowPowerThreshold
|
|
mock.lockDeviceSetNvLinkDeviceLowPowerThreshold.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetNvLinkUtilizationControl calls DeviceSetNvLinkUtilizationControlFunc.
|
|
func (mock *Interface) DeviceSetNvLinkUtilizationControl(device nvml.Device, n1 int, n2 int, nvLinkUtilizationControl *nvml.NvLinkUtilizationControl, b bool) nvml.Return {
|
|
if mock.DeviceSetNvLinkUtilizationControlFunc == nil {
|
|
panic("Interface.DeviceSetNvLinkUtilizationControlFunc: method is nil but Interface.DeviceSetNvLinkUtilizationControl was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
NvLinkUtilizationControl *nvml.NvLinkUtilizationControl
|
|
B bool
|
|
}{
|
|
Device: device,
|
|
N1: n1,
|
|
N2: n2,
|
|
NvLinkUtilizationControl: nvLinkUtilizationControl,
|
|
B: b,
|
|
}
|
|
mock.lockDeviceSetNvLinkUtilizationControl.Lock()
|
|
mock.calls.DeviceSetNvLinkUtilizationControl = append(mock.calls.DeviceSetNvLinkUtilizationControl, callInfo)
|
|
mock.lockDeviceSetNvLinkUtilizationControl.Unlock()
|
|
return mock.DeviceSetNvLinkUtilizationControlFunc(device, n1, n2, nvLinkUtilizationControl, b)
|
|
}
|
|
|
|
// DeviceSetNvLinkUtilizationControlCalls gets all the calls that were made to DeviceSetNvLinkUtilizationControl.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetNvLinkUtilizationControlCalls())
|
|
func (mock *Interface) DeviceSetNvLinkUtilizationControlCalls() []struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
NvLinkUtilizationControl *nvml.NvLinkUtilizationControl
|
|
B bool
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N1 int
|
|
N2 int
|
|
NvLinkUtilizationControl *nvml.NvLinkUtilizationControl
|
|
B bool
|
|
}
|
|
mock.lockDeviceSetNvLinkUtilizationControl.RLock()
|
|
calls = mock.calls.DeviceSetNvLinkUtilizationControl
|
|
mock.lockDeviceSetNvLinkUtilizationControl.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetPersistenceMode calls DeviceSetPersistenceModeFunc.
|
|
func (mock *Interface) DeviceSetPersistenceMode(device nvml.Device, enableState nvml.EnableState) nvml.Return {
|
|
if mock.DeviceSetPersistenceModeFunc == nil {
|
|
panic("Interface.DeviceSetPersistenceModeFunc: method is nil but Interface.DeviceSetPersistenceMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
}{
|
|
Device: device,
|
|
EnableState: enableState,
|
|
}
|
|
mock.lockDeviceSetPersistenceMode.Lock()
|
|
mock.calls.DeviceSetPersistenceMode = append(mock.calls.DeviceSetPersistenceMode, callInfo)
|
|
mock.lockDeviceSetPersistenceMode.Unlock()
|
|
return mock.DeviceSetPersistenceModeFunc(device, enableState)
|
|
}
|
|
|
|
// DeviceSetPersistenceModeCalls gets all the calls that were made to DeviceSetPersistenceMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetPersistenceModeCalls())
|
|
func (mock *Interface) DeviceSetPersistenceModeCalls() []struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
EnableState nvml.EnableState
|
|
}
|
|
mock.lockDeviceSetPersistenceMode.RLock()
|
|
calls = mock.calls.DeviceSetPersistenceMode
|
|
mock.lockDeviceSetPersistenceMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetPowerManagementLimit calls DeviceSetPowerManagementLimitFunc.
|
|
func (mock *Interface) DeviceSetPowerManagementLimit(device nvml.Device, v uint32) nvml.Return {
|
|
if mock.DeviceSetPowerManagementLimitFunc == nil {
|
|
panic("Interface.DeviceSetPowerManagementLimitFunc: method is nil but Interface.DeviceSetPowerManagementLimit was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
V uint32
|
|
}{
|
|
Device: device,
|
|
V: v,
|
|
}
|
|
mock.lockDeviceSetPowerManagementLimit.Lock()
|
|
mock.calls.DeviceSetPowerManagementLimit = append(mock.calls.DeviceSetPowerManagementLimit, callInfo)
|
|
mock.lockDeviceSetPowerManagementLimit.Unlock()
|
|
return mock.DeviceSetPowerManagementLimitFunc(device, v)
|
|
}
|
|
|
|
// DeviceSetPowerManagementLimitCalls gets all the calls that were made to DeviceSetPowerManagementLimit.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetPowerManagementLimitCalls())
|
|
func (mock *Interface) DeviceSetPowerManagementLimitCalls() []struct {
|
|
Device nvml.Device
|
|
V uint32
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
V uint32
|
|
}
|
|
mock.lockDeviceSetPowerManagementLimit.RLock()
|
|
calls = mock.calls.DeviceSetPowerManagementLimit
|
|
mock.lockDeviceSetPowerManagementLimit.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetTemperatureThreshold calls DeviceSetTemperatureThresholdFunc.
|
|
func (mock *Interface) DeviceSetTemperatureThreshold(device nvml.Device, temperatureThresholds nvml.TemperatureThresholds, n int) nvml.Return {
|
|
if mock.DeviceSetTemperatureThresholdFunc == nil {
|
|
panic("Interface.DeviceSetTemperatureThresholdFunc: method is nil but Interface.DeviceSetTemperatureThreshold was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
N int
|
|
}{
|
|
Device: device,
|
|
TemperatureThresholds: temperatureThresholds,
|
|
N: n,
|
|
}
|
|
mock.lockDeviceSetTemperatureThreshold.Lock()
|
|
mock.calls.DeviceSetTemperatureThreshold = append(mock.calls.DeviceSetTemperatureThreshold, callInfo)
|
|
mock.lockDeviceSetTemperatureThreshold.Unlock()
|
|
return mock.DeviceSetTemperatureThresholdFunc(device, temperatureThresholds, n)
|
|
}
|
|
|
|
// DeviceSetTemperatureThresholdCalls gets all the calls that were made to DeviceSetTemperatureThreshold.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetTemperatureThresholdCalls())
|
|
func (mock *Interface) DeviceSetTemperatureThresholdCalls() []struct {
|
|
Device nvml.Device
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
N int
|
|
}
|
|
mock.lockDeviceSetTemperatureThreshold.RLock()
|
|
calls = mock.calls.DeviceSetTemperatureThreshold
|
|
mock.lockDeviceSetTemperatureThreshold.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetVgpuSchedulerState calls DeviceSetVgpuSchedulerStateFunc.
|
|
func (mock *Interface) DeviceSetVgpuSchedulerState(device nvml.Device, vgpuSchedulerSetState *nvml.VgpuSchedulerSetState) nvml.Return {
|
|
if mock.DeviceSetVgpuSchedulerStateFunc == nil {
|
|
panic("Interface.DeviceSetVgpuSchedulerStateFunc: method is nil but Interface.DeviceSetVgpuSchedulerState was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
|
|
}{
|
|
Device: device,
|
|
VgpuSchedulerSetState: vgpuSchedulerSetState,
|
|
}
|
|
mock.lockDeviceSetVgpuSchedulerState.Lock()
|
|
mock.calls.DeviceSetVgpuSchedulerState = append(mock.calls.DeviceSetVgpuSchedulerState, callInfo)
|
|
mock.lockDeviceSetVgpuSchedulerState.Unlock()
|
|
return mock.DeviceSetVgpuSchedulerStateFunc(device, vgpuSchedulerSetState)
|
|
}
|
|
|
|
// DeviceSetVgpuSchedulerStateCalls gets all the calls that were made to DeviceSetVgpuSchedulerState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetVgpuSchedulerStateCalls())
|
|
func (mock *Interface) DeviceSetVgpuSchedulerStateCalls() []struct {
|
|
Device nvml.Device
|
|
VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
|
|
}
|
|
mock.lockDeviceSetVgpuSchedulerState.RLock()
|
|
calls = mock.calls.DeviceSetVgpuSchedulerState
|
|
mock.lockDeviceSetVgpuSchedulerState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceSetVirtualizationMode calls DeviceSetVirtualizationModeFunc.
|
|
func (mock *Interface) DeviceSetVirtualizationMode(device nvml.Device, gpuVirtualizationMode nvml.GpuVirtualizationMode) nvml.Return {
|
|
if mock.DeviceSetVirtualizationModeFunc == nil {
|
|
panic("Interface.DeviceSetVirtualizationModeFunc: method is nil but Interface.DeviceSetVirtualizationMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
GpuVirtualizationMode nvml.GpuVirtualizationMode
|
|
}{
|
|
Device: device,
|
|
GpuVirtualizationMode: gpuVirtualizationMode,
|
|
}
|
|
mock.lockDeviceSetVirtualizationMode.Lock()
|
|
mock.calls.DeviceSetVirtualizationMode = append(mock.calls.DeviceSetVirtualizationMode, callInfo)
|
|
mock.lockDeviceSetVirtualizationMode.Unlock()
|
|
return mock.DeviceSetVirtualizationModeFunc(device, gpuVirtualizationMode)
|
|
}
|
|
|
|
// DeviceSetVirtualizationModeCalls gets all the calls that were made to DeviceSetVirtualizationMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceSetVirtualizationModeCalls())
|
|
func (mock *Interface) DeviceSetVirtualizationModeCalls() []struct {
|
|
Device nvml.Device
|
|
GpuVirtualizationMode nvml.GpuVirtualizationMode
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
GpuVirtualizationMode nvml.GpuVirtualizationMode
|
|
}
|
|
mock.lockDeviceSetVirtualizationMode.RLock()
|
|
calls = mock.calls.DeviceSetVirtualizationMode
|
|
mock.lockDeviceSetVirtualizationMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// DeviceValidateInforom calls DeviceValidateInforomFunc.
|
|
func (mock *Interface) DeviceValidateInforom(device nvml.Device) nvml.Return {
|
|
if mock.DeviceValidateInforomFunc == nil {
|
|
panic("Interface.DeviceValidateInforomFunc: method is nil but Interface.DeviceValidateInforom was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockDeviceValidateInforom.Lock()
|
|
mock.calls.DeviceValidateInforom = append(mock.calls.DeviceValidateInforom, callInfo)
|
|
mock.lockDeviceValidateInforom.Unlock()
|
|
return mock.DeviceValidateInforomFunc(device)
|
|
}
|
|
|
|
// DeviceValidateInforomCalls gets all the calls that were made to DeviceValidateInforom.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.DeviceValidateInforomCalls())
|
|
func (mock *Interface) DeviceValidateInforomCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockDeviceValidateInforom.RLock()
|
|
calls = mock.calls.DeviceValidateInforom
|
|
mock.lockDeviceValidateInforom.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// ErrorString calls ErrorStringFunc.
|
|
func (mock *Interface) ErrorString(returnMoqParam nvml.Return) string {
|
|
if mock.ErrorStringFunc == nil {
|
|
panic("Interface.ErrorStringFunc: method is nil but Interface.ErrorString was just called")
|
|
}
|
|
callInfo := struct {
|
|
ReturnMoqParam nvml.Return
|
|
}{
|
|
ReturnMoqParam: returnMoqParam,
|
|
}
|
|
mock.lockErrorString.Lock()
|
|
mock.calls.ErrorString = append(mock.calls.ErrorString, callInfo)
|
|
mock.lockErrorString.Unlock()
|
|
return mock.ErrorStringFunc(returnMoqParam)
|
|
}
|
|
|
|
// ErrorStringCalls gets all the calls that were made to ErrorString.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.ErrorStringCalls())
|
|
func (mock *Interface) ErrorStringCalls() []struct {
|
|
ReturnMoqParam nvml.Return
|
|
} {
|
|
var calls []struct {
|
|
ReturnMoqParam nvml.Return
|
|
}
|
|
mock.lockErrorString.RLock()
|
|
calls = mock.calls.ErrorString
|
|
mock.lockErrorString.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// EventSetCreate calls EventSetCreateFunc.
|
|
func (mock *Interface) EventSetCreate() (nvml.EventSet, nvml.Return) {
|
|
if mock.EventSetCreateFunc == nil {
|
|
panic("Interface.EventSetCreateFunc: method is nil but Interface.EventSetCreate was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockEventSetCreate.Lock()
|
|
mock.calls.EventSetCreate = append(mock.calls.EventSetCreate, callInfo)
|
|
mock.lockEventSetCreate.Unlock()
|
|
return mock.EventSetCreateFunc()
|
|
}
|
|
|
|
// EventSetCreateCalls gets all the calls that were made to EventSetCreate.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.EventSetCreateCalls())
|
|
func (mock *Interface) EventSetCreateCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockEventSetCreate.RLock()
|
|
calls = mock.calls.EventSetCreate
|
|
mock.lockEventSetCreate.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// EventSetFree calls EventSetFreeFunc.
|
|
func (mock *Interface) EventSetFree(eventSet nvml.EventSet) nvml.Return {
|
|
if mock.EventSetFreeFunc == nil {
|
|
panic("Interface.EventSetFreeFunc: method is nil but Interface.EventSetFree was just called")
|
|
}
|
|
callInfo := struct {
|
|
EventSet nvml.EventSet
|
|
}{
|
|
EventSet: eventSet,
|
|
}
|
|
mock.lockEventSetFree.Lock()
|
|
mock.calls.EventSetFree = append(mock.calls.EventSetFree, callInfo)
|
|
mock.lockEventSetFree.Unlock()
|
|
return mock.EventSetFreeFunc(eventSet)
|
|
}
|
|
|
|
// EventSetFreeCalls gets all the calls that were made to EventSetFree.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.EventSetFreeCalls())
|
|
func (mock *Interface) EventSetFreeCalls() []struct {
|
|
EventSet nvml.EventSet
|
|
} {
|
|
var calls []struct {
|
|
EventSet nvml.EventSet
|
|
}
|
|
mock.lockEventSetFree.RLock()
|
|
calls = mock.calls.EventSetFree
|
|
mock.lockEventSetFree.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// EventSetWait calls EventSetWaitFunc.
|
|
func (mock *Interface) EventSetWait(eventSet nvml.EventSet, v uint32) (nvml.EventData, nvml.Return) {
|
|
if mock.EventSetWaitFunc == nil {
|
|
panic("Interface.EventSetWaitFunc: method is nil but Interface.EventSetWait was just called")
|
|
}
|
|
callInfo := struct {
|
|
EventSet nvml.EventSet
|
|
V uint32
|
|
}{
|
|
EventSet: eventSet,
|
|
V: v,
|
|
}
|
|
mock.lockEventSetWait.Lock()
|
|
mock.calls.EventSetWait = append(mock.calls.EventSetWait, callInfo)
|
|
mock.lockEventSetWait.Unlock()
|
|
return mock.EventSetWaitFunc(eventSet, v)
|
|
}
|
|
|
|
// EventSetWaitCalls gets all the calls that were made to EventSetWait.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.EventSetWaitCalls())
|
|
func (mock *Interface) EventSetWaitCalls() []struct {
|
|
EventSet nvml.EventSet
|
|
V uint32
|
|
} {
|
|
var calls []struct {
|
|
EventSet nvml.EventSet
|
|
V uint32
|
|
}
|
|
mock.lockEventSetWait.RLock()
|
|
calls = mock.calls.EventSetWait
|
|
mock.lockEventSetWait.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// Extensions calls ExtensionsFunc.
|
|
func (mock *Interface) Extensions() nvml.ExtendedInterface {
|
|
if mock.ExtensionsFunc == nil {
|
|
panic("Interface.ExtensionsFunc: method is nil but Interface.Extensions was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockExtensions.Lock()
|
|
mock.calls.Extensions = append(mock.calls.Extensions, callInfo)
|
|
mock.lockExtensions.Unlock()
|
|
return mock.ExtensionsFunc()
|
|
}
|
|
|
|
// ExtensionsCalls gets all the calls that were made to Extensions.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.ExtensionsCalls())
|
|
func (mock *Interface) ExtensionsCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockExtensions.RLock()
|
|
calls = mock.calls.Extensions
|
|
mock.lockExtensions.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetExcludedDeviceCount calls GetExcludedDeviceCountFunc.
|
|
func (mock *Interface) GetExcludedDeviceCount() (int, nvml.Return) {
|
|
if mock.GetExcludedDeviceCountFunc == nil {
|
|
panic("Interface.GetExcludedDeviceCountFunc: method is nil but Interface.GetExcludedDeviceCount was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetExcludedDeviceCount.Lock()
|
|
mock.calls.GetExcludedDeviceCount = append(mock.calls.GetExcludedDeviceCount, callInfo)
|
|
mock.lockGetExcludedDeviceCount.Unlock()
|
|
return mock.GetExcludedDeviceCountFunc()
|
|
}
|
|
|
|
// GetExcludedDeviceCountCalls gets all the calls that were made to GetExcludedDeviceCount.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GetExcludedDeviceCountCalls())
|
|
func (mock *Interface) GetExcludedDeviceCountCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetExcludedDeviceCount.RLock()
|
|
calls = mock.calls.GetExcludedDeviceCount
|
|
mock.lockGetExcludedDeviceCount.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetExcludedDeviceInfoByIndex calls GetExcludedDeviceInfoByIndexFunc.
|
|
func (mock *Interface) GetExcludedDeviceInfoByIndex(n int) (nvml.ExcludedDeviceInfo, nvml.Return) {
|
|
if mock.GetExcludedDeviceInfoByIndexFunc == nil {
|
|
panic("Interface.GetExcludedDeviceInfoByIndexFunc: method is nil but Interface.GetExcludedDeviceInfoByIndex was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockGetExcludedDeviceInfoByIndex.Lock()
|
|
mock.calls.GetExcludedDeviceInfoByIndex = append(mock.calls.GetExcludedDeviceInfoByIndex, callInfo)
|
|
mock.lockGetExcludedDeviceInfoByIndex.Unlock()
|
|
return mock.GetExcludedDeviceInfoByIndexFunc(n)
|
|
}
|
|
|
|
// GetExcludedDeviceInfoByIndexCalls gets all the calls that were made to GetExcludedDeviceInfoByIndex.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GetExcludedDeviceInfoByIndexCalls())
|
|
func (mock *Interface) GetExcludedDeviceInfoByIndexCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockGetExcludedDeviceInfoByIndex.RLock()
|
|
calls = mock.calls.GetExcludedDeviceInfoByIndex
|
|
mock.lockGetExcludedDeviceInfoByIndex.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetVgpuCompatibility calls GetVgpuCompatibilityFunc.
|
|
func (mock *Interface) GetVgpuCompatibility(vgpuMetadata *nvml.VgpuMetadata, vgpuPgpuMetadata *nvml.VgpuPgpuMetadata) (nvml.VgpuPgpuCompatibility, nvml.Return) {
|
|
if mock.GetVgpuCompatibilityFunc == nil {
|
|
panic("Interface.GetVgpuCompatibilityFunc: method is nil but Interface.GetVgpuCompatibility was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuMetadata *nvml.VgpuMetadata
|
|
VgpuPgpuMetadata *nvml.VgpuPgpuMetadata
|
|
}{
|
|
VgpuMetadata: vgpuMetadata,
|
|
VgpuPgpuMetadata: vgpuPgpuMetadata,
|
|
}
|
|
mock.lockGetVgpuCompatibility.Lock()
|
|
mock.calls.GetVgpuCompatibility = append(mock.calls.GetVgpuCompatibility, callInfo)
|
|
mock.lockGetVgpuCompatibility.Unlock()
|
|
return mock.GetVgpuCompatibilityFunc(vgpuMetadata, vgpuPgpuMetadata)
|
|
}
|
|
|
|
// GetVgpuCompatibilityCalls gets all the calls that were made to GetVgpuCompatibility.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GetVgpuCompatibilityCalls())
|
|
func (mock *Interface) GetVgpuCompatibilityCalls() []struct {
|
|
VgpuMetadata *nvml.VgpuMetadata
|
|
VgpuPgpuMetadata *nvml.VgpuPgpuMetadata
|
|
} {
|
|
var calls []struct {
|
|
VgpuMetadata *nvml.VgpuMetadata
|
|
VgpuPgpuMetadata *nvml.VgpuPgpuMetadata
|
|
}
|
|
mock.lockGetVgpuCompatibility.RLock()
|
|
calls = mock.calls.GetVgpuCompatibility
|
|
mock.lockGetVgpuCompatibility.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetVgpuDriverCapabilities calls GetVgpuDriverCapabilitiesFunc.
|
|
func (mock *Interface) GetVgpuDriverCapabilities(vgpuDriverCapability nvml.VgpuDriverCapability) (bool, nvml.Return) {
|
|
if mock.GetVgpuDriverCapabilitiesFunc == nil {
|
|
panic("Interface.GetVgpuDriverCapabilitiesFunc: method is nil but Interface.GetVgpuDriverCapabilities was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuDriverCapability nvml.VgpuDriverCapability
|
|
}{
|
|
VgpuDriverCapability: vgpuDriverCapability,
|
|
}
|
|
mock.lockGetVgpuDriverCapabilities.Lock()
|
|
mock.calls.GetVgpuDriverCapabilities = append(mock.calls.GetVgpuDriverCapabilities, callInfo)
|
|
mock.lockGetVgpuDriverCapabilities.Unlock()
|
|
return mock.GetVgpuDriverCapabilitiesFunc(vgpuDriverCapability)
|
|
}
|
|
|
|
// GetVgpuDriverCapabilitiesCalls gets all the calls that were made to GetVgpuDriverCapabilities.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GetVgpuDriverCapabilitiesCalls())
|
|
func (mock *Interface) GetVgpuDriverCapabilitiesCalls() []struct {
|
|
VgpuDriverCapability nvml.VgpuDriverCapability
|
|
} {
|
|
var calls []struct {
|
|
VgpuDriverCapability nvml.VgpuDriverCapability
|
|
}
|
|
mock.lockGetVgpuDriverCapabilities.RLock()
|
|
calls = mock.calls.GetVgpuDriverCapabilities
|
|
mock.lockGetVgpuDriverCapabilities.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetVgpuVersion calls GetVgpuVersionFunc.
|
|
func (mock *Interface) GetVgpuVersion() (nvml.VgpuVersion, nvml.VgpuVersion, nvml.Return) {
|
|
if mock.GetVgpuVersionFunc == nil {
|
|
panic("Interface.GetVgpuVersionFunc: method is nil but Interface.GetVgpuVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetVgpuVersion.Lock()
|
|
mock.calls.GetVgpuVersion = append(mock.calls.GetVgpuVersion, callInfo)
|
|
mock.lockGetVgpuVersion.Unlock()
|
|
return mock.GetVgpuVersionFunc()
|
|
}
|
|
|
|
// GetVgpuVersionCalls gets all the calls that were made to GetVgpuVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GetVgpuVersionCalls())
|
|
func (mock *Interface) GetVgpuVersionCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetVgpuVersion.RLock()
|
|
calls = mock.calls.GetVgpuVersion
|
|
mock.lockGetVgpuVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpmMetricsGet calls GpmMetricsGetFunc.
|
|
func (mock *Interface) GpmMetricsGet(gpmMetricsGetType *nvml.GpmMetricsGetType) nvml.Return {
|
|
if mock.GpmMetricsGetFunc == nil {
|
|
panic("Interface.GpmMetricsGetFunc: method is nil but Interface.GpmMetricsGet was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpmMetricsGetType *nvml.GpmMetricsGetType
|
|
}{
|
|
GpmMetricsGetType: gpmMetricsGetType,
|
|
}
|
|
mock.lockGpmMetricsGet.Lock()
|
|
mock.calls.GpmMetricsGet = append(mock.calls.GpmMetricsGet, callInfo)
|
|
mock.lockGpmMetricsGet.Unlock()
|
|
return mock.GpmMetricsGetFunc(gpmMetricsGetType)
|
|
}
|
|
|
|
// GpmMetricsGetCalls gets all the calls that were made to GpmMetricsGet.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpmMetricsGetCalls())
|
|
func (mock *Interface) GpmMetricsGetCalls() []struct {
|
|
GpmMetricsGetType *nvml.GpmMetricsGetType
|
|
} {
|
|
var calls []struct {
|
|
GpmMetricsGetType *nvml.GpmMetricsGetType
|
|
}
|
|
mock.lockGpmMetricsGet.RLock()
|
|
calls = mock.calls.GpmMetricsGet
|
|
mock.lockGpmMetricsGet.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpmMetricsGetV calls GpmMetricsGetVFunc.
|
|
func (mock *Interface) GpmMetricsGetV(gpmMetricsGetType *nvml.GpmMetricsGetType) nvml.GpmMetricsGetVType {
|
|
if mock.GpmMetricsGetVFunc == nil {
|
|
panic("Interface.GpmMetricsGetVFunc: method is nil but Interface.GpmMetricsGetV was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpmMetricsGetType *nvml.GpmMetricsGetType
|
|
}{
|
|
GpmMetricsGetType: gpmMetricsGetType,
|
|
}
|
|
mock.lockGpmMetricsGetV.Lock()
|
|
mock.calls.GpmMetricsGetV = append(mock.calls.GpmMetricsGetV, callInfo)
|
|
mock.lockGpmMetricsGetV.Unlock()
|
|
return mock.GpmMetricsGetVFunc(gpmMetricsGetType)
|
|
}
|
|
|
|
// GpmMetricsGetVCalls gets all the calls that were made to GpmMetricsGetV.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpmMetricsGetVCalls())
|
|
func (mock *Interface) GpmMetricsGetVCalls() []struct {
|
|
GpmMetricsGetType *nvml.GpmMetricsGetType
|
|
} {
|
|
var calls []struct {
|
|
GpmMetricsGetType *nvml.GpmMetricsGetType
|
|
}
|
|
mock.lockGpmMetricsGetV.RLock()
|
|
calls = mock.calls.GpmMetricsGetV
|
|
mock.lockGpmMetricsGetV.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpmMigSampleGet calls GpmMigSampleGetFunc.
|
|
func (mock *Interface) GpmMigSampleGet(device nvml.Device, n int, gpmSample nvml.GpmSample) nvml.Return {
|
|
if mock.GpmMigSampleGetFunc == nil {
|
|
panic("Interface.GpmMigSampleGetFunc: method is nil but Interface.GpmMigSampleGet was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
N int
|
|
GpmSample nvml.GpmSample
|
|
}{
|
|
Device: device,
|
|
N: n,
|
|
GpmSample: gpmSample,
|
|
}
|
|
mock.lockGpmMigSampleGet.Lock()
|
|
mock.calls.GpmMigSampleGet = append(mock.calls.GpmMigSampleGet, callInfo)
|
|
mock.lockGpmMigSampleGet.Unlock()
|
|
return mock.GpmMigSampleGetFunc(device, n, gpmSample)
|
|
}
|
|
|
|
// GpmMigSampleGetCalls gets all the calls that were made to GpmMigSampleGet.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpmMigSampleGetCalls())
|
|
func (mock *Interface) GpmMigSampleGetCalls() []struct {
|
|
Device nvml.Device
|
|
N int
|
|
GpmSample nvml.GpmSample
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
N int
|
|
GpmSample nvml.GpmSample
|
|
}
|
|
mock.lockGpmMigSampleGet.RLock()
|
|
calls = mock.calls.GpmMigSampleGet
|
|
mock.lockGpmMigSampleGet.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpmQueryDeviceSupport calls GpmQueryDeviceSupportFunc.
|
|
func (mock *Interface) GpmQueryDeviceSupport(device nvml.Device) (nvml.GpmSupport, nvml.Return) {
|
|
if mock.GpmQueryDeviceSupportFunc == nil {
|
|
panic("Interface.GpmQueryDeviceSupportFunc: method is nil but Interface.GpmQueryDeviceSupport was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockGpmQueryDeviceSupport.Lock()
|
|
mock.calls.GpmQueryDeviceSupport = append(mock.calls.GpmQueryDeviceSupport, callInfo)
|
|
mock.lockGpmQueryDeviceSupport.Unlock()
|
|
return mock.GpmQueryDeviceSupportFunc(device)
|
|
}
|
|
|
|
// GpmQueryDeviceSupportCalls gets all the calls that were made to GpmQueryDeviceSupport.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpmQueryDeviceSupportCalls())
|
|
func (mock *Interface) GpmQueryDeviceSupportCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockGpmQueryDeviceSupport.RLock()
|
|
calls = mock.calls.GpmQueryDeviceSupport
|
|
mock.lockGpmQueryDeviceSupport.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpmQueryDeviceSupportV calls GpmQueryDeviceSupportVFunc.
|
|
func (mock *Interface) GpmQueryDeviceSupportV(device nvml.Device) nvml.GpmSupportV {
|
|
if mock.GpmQueryDeviceSupportVFunc == nil {
|
|
panic("Interface.GpmQueryDeviceSupportVFunc: method is nil but Interface.GpmQueryDeviceSupportV was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockGpmQueryDeviceSupportV.Lock()
|
|
mock.calls.GpmQueryDeviceSupportV = append(mock.calls.GpmQueryDeviceSupportV, callInfo)
|
|
mock.lockGpmQueryDeviceSupportV.Unlock()
|
|
return mock.GpmQueryDeviceSupportVFunc(device)
|
|
}
|
|
|
|
// GpmQueryDeviceSupportVCalls gets all the calls that were made to GpmQueryDeviceSupportV.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpmQueryDeviceSupportVCalls())
|
|
func (mock *Interface) GpmQueryDeviceSupportVCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockGpmQueryDeviceSupportV.RLock()
|
|
calls = mock.calls.GpmQueryDeviceSupportV
|
|
mock.lockGpmQueryDeviceSupportV.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpmSampleAlloc calls GpmSampleAllocFunc.
|
|
func (mock *Interface) GpmSampleAlloc() (nvml.GpmSample, nvml.Return) {
|
|
if mock.GpmSampleAllocFunc == nil {
|
|
panic("Interface.GpmSampleAllocFunc: method is nil but Interface.GpmSampleAlloc was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGpmSampleAlloc.Lock()
|
|
mock.calls.GpmSampleAlloc = append(mock.calls.GpmSampleAlloc, callInfo)
|
|
mock.lockGpmSampleAlloc.Unlock()
|
|
return mock.GpmSampleAllocFunc()
|
|
}
|
|
|
|
// GpmSampleAllocCalls gets all the calls that were made to GpmSampleAlloc.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpmSampleAllocCalls())
|
|
func (mock *Interface) GpmSampleAllocCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGpmSampleAlloc.RLock()
|
|
calls = mock.calls.GpmSampleAlloc
|
|
mock.lockGpmSampleAlloc.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpmSampleFree calls GpmSampleFreeFunc.
|
|
func (mock *Interface) GpmSampleFree(gpmSample nvml.GpmSample) nvml.Return {
|
|
if mock.GpmSampleFreeFunc == nil {
|
|
panic("Interface.GpmSampleFreeFunc: method is nil but Interface.GpmSampleFree was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpmSample nvml.GpmSample
|
|
}{
|
|
GpmSample: gpmSample,
|
|
}
|
|
mock.lockGpmSampleFree.Lock()
|
|
mock.calls.GpmSampleFree = append(mock.calls.GpmSampleFree, callInfo)
|
|
mock.lockGpmSampleFree.Unlock()
|
|
return mock.GpmSampleFreeFunc(gpmSample)
|
|
}
|
|
|
|
// GpmSampleFreeCalls gets all the calls that were made to GpmSampleFree.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpmSampleFreeCalls())
|
|
func (mock *Interface) GpmSampleFreeCalls() []struct {
|
|
GpmSample nvml.GpmSample
|
|
} {
|
|
var calls []struct {
|
|
GpmSample nvml.GpmSample
|
|
}
|
|
mock.lockGpmSampleFree.RLock()
|
|
calls = mock.calls.GpmSampleFree
|
|
mock.lockGpmSampleFree.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpmSampleGet calls GpmSampleGetFunc.
|
|
func (mock *Interface) GpmSampleGet(device nvml.Device, gpmSample nvml.GpmSample) nvml.Return {
|
|
if mock.GpmSampleGetFunc == nil {
|
|
panic("Interface.GpmSampleGetFunc: method is nil but Interface.GpmSampleGet was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
GpmSample nvml.GpmSample
|
|
}{
|
|
Device: device,
|
|
GpmSample: gpmSample,
|
|
}
|
|
mock.lockGpmSampleGet.Lock()
|
|
mock.calls.GpmSampleGet = append(mock.calls.GpmSampleGet, callInfo)
|
|
mock.lockGpmSampleGet.Unlock()
|
|
return mock.GpmSampleGetFunc(device, gpmSample)
|
|
}
|
|
|
|
// GpmSampleGetCalls gets all the calls that were made to GpmSampleGet.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpmSampleGetCalls())
|
|
func (mock *Interface) GpmSampleGetCalls() []struct {
|
|
Device nvml.Device
|
|
GpmSample nvml.GpmSample
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
GpmSample nvml.GpmSample
|
|
}
|
|
mock.lockGpmSampleGet.RLock()
|
|
calls = mock.calls.GpmSampleGet
|
|
mock.lockGpmSampleGet.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpuInstanceCreateComputeInstance calls GpuInstanceCreateComputeInstanceFunc.
|
|
func (mock *Interface) GpuInstanceCreateComputeInstance(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) (nvml.ComputeInstance, nvml.Return) {
|
|
if mock.GpuInstanceCreateComputeInstanceFunc == nil {
|
|
panic("Interface.GpuInstanceCreateComputeInstanceFunc: method is nil but Interface.GpuInstanceCreateComputeInstance was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
}{
|
|
GpuInstance: gpuInstance,
|
|
ComputeInstanceProfileInfo: computeInstanceProfileInfo,
|
|
}
|
|
mock.lockGpuInstanceCreateComputeInstance.Lock()
|
|
mock.calls.GpuInstanceCreateComputeInstance = append(mock.calls.GpuInstanceCreateComputeInstance, callInfo)
|
|
mock.lockGpuInstanceCreateComputeInstance.Unlock()
|
|
return mock.GpuInstanceCreateComputeInstanceFunc(gpuInstance, computeInstanceProfileInfo)
|
|
}
|
|
|
|
// GpuInstanceCreateComputeInstanceCalls gets all the calls that were made to GpuInstanceCreateComputeInstance.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpuInstanceCreateComputeInstanceCalls())
|
|
func (mock *Interface) GpuInstanceCreateComputeInstanceCalls() []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
} {
|
|
var calls []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
}
|
|
mock.lockGpuInstanceCreateComputeInstance.RLock()
|
|
calls = mock.calls.GpuInstanceCreateComputeInstance
|
|
mock.lockGpuInstanceCreateComputeInstance.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpuInstanceCreateComputeInstanceWithPlacement calls GpuInstanceCreateComputeInstanceWithPlacementFunc.
|
|
func (mock *Interface) GpuInstanceCreateComputeInstanceWithPlacement(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo, computeInstancePlacement *nvml.ComputeInstancePlacement) (nvml.ComputeInstance, nvml.Return) {
|
|
if mock.GpuInstanceCreateComputeInstanceWithPlacementFunc == nil {
|
|
panic("Interface.GpuInstanceCreateComputeInstanceWithPlacementFunc: method is nil but Interface.GpuInstanceCreateComputeInstanceWithPlacement was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
ComputeInstancePlacement *nvml.ComputeInstancePlacement
|
|
}{
|
|
GpuInstance: gpuInstance,
|
|
ComputeInstanceProfileInfo: computeInstanceProfileInfo,
|
|
ComputeInstancePlacement: computeInstancePlacement,
|
|
}
|
|
mock.lockGpuInstanceCreateComputeInstanceWithPlacement.Lock()
|
|
mock.calls.GpuInstanceCreateComputeInstanceWithPlacement = append(mock.calls.GpuInstanceCreateComputeInstanceWithPlacement, callInfo)
|
|
mock.lockGpuInstanceCreateComputeInstanceWithPlacement.Unlock()
|
|
return mock.GpuInstanceCreateComputeInstanceWithPlacementFunc(gpuInstance, computeInstanceProfileInfo, computeInstancePlacement)
|
|
}
|
|
|
|
// GpuInstanceCreateComputeInstanceWithPlacementCalls gets all the calls that were made to GpuInstanceCreateComputeInstanceWithPlacement.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpuInstanceCreateComputeInstanceWithPlacementCalls())
|
|
func (mock *Interface) GpuInstanceCreateComputeInstanceWithPlacementCalls() []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
ComputeInstancePlacement *nvml.ComputeInstancePlacement
|
|
} {
|
|
var calls []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
ComputeInstancePlacement *nvml.ComputeInstancePlacement
|
|
}
|
|
mock.lockGpuInstanceCreateComputeInstanceWithPlacement.RLock()
|
|
calls = mock.calls.GpuInstanceCreateComputeInstanceWithPlacement
|
|
mock.lockGpuInstanceCreateComputeInstanceWithPlacement.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpuInstanceDestroy calls GpuInstanceDestroyFunc.
|
|
func (mock *Interface) GpuInstanceDestroy(gpuInstance nvml.GpuInstance) nvml.Return {
|
|
if mock.GpuInstanceDestroyFunc == nil {
|
|
panic("Interface.GpuInstanceDestroyFunc: method is nil but Interface.GpuInstanceDestroy was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstance nvml.GpuInstance
|
|
}{
|
|
GpuInstance: gpuInstance,
|
|
}
|
|
mock.lockGpuInstanceDestroy.Lock()
|
|
mock.calls.GpuInstanceDestroy = append(mock.calls.GpuInstanceDestroy, callInfo)
|
|
mock.lockGpuInstanceDestroy.Unlock()
|
|
return mock.GpuInstanceDestroyFunc(gpuInstance)
|
|
}
|
|
|
|
// GpuInstanceDestroyCalls gets all the calls that were made to GpuInstanceDestroy.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpuInstanceDestroyCalls())
|
|
func (mock *Interface) GpuInstanceDestroyCalls() []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
} {
|
|
var calls []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
}
|
|
mock.lockGpuInstanceDestroy.RLock()
|
|
calls = mock.calls.GpuInstanceDestroy
|
|
mock.lockGpuInstanceDestroy.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpuInstanceGetComputeInstanceById calls GpuInstanceGetComputeInstanceByIdFunc.
|
|
func (mock *Interface) GpuInstanceGetComputeInstanceById(gpuInstance nvml.GpuInstance, n int) (nvml.ComputeInstance, nvml.Return) {
|
|
if mock.GpuInstanceGetComputeInstanceByIdFunc == nil {
|
|
panic("Interface.GpuInstanceGetComputeInstanceByIdFunc: method is nil but Interface.GpuInstanceGetComputeInstanceById was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstance nvml.GpuInstance
|
|
N int
|
|
}{
|
|
GpuInstance: gpuInstance,
|
|
N: n,
|
|
}
|
|
mock.lockGpuInstanceGetComputeInstanceById.Lock()
|
|
mock.calls.GpuInstanceGetComputeInstanceById = append(mock.calls.GpuInstanceGetComputeInstanceById, callInfo)
|
|
mock.lockGpuInstanceGetComputeInstanceById.Unlock()
|
|
return mock.GpuInstanceGetComputeInstanceByIdFunc(gpuInstance, n)
|
|
}
|
|
|
|
// GpuInstanceGetComputeInstanceByIdCalls gets all the calls that were made to GpuInstanceGetComputeInstanceById.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpuInstanceGetComputeInstanceByIdCalls())
|
|
func (mock *Interface) GpuInstanceGetComputeInstanceByIdCalls() []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
N int
|
|
}
|
|
mock.lockGpuInstanceGetComputeInstanceById.RLock()
|
|
calls = mock.calls.GpuInstanceGetComputeInstanceById
|
|
mock.lockGpuInstanceGetComputeInstanceById.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpuInstanceGetComputeInstancePossiblePlacements calls GpuInstanceGetComputeInstancePossiblePlacementsFunc.
|
|
func (mock *Interface) GpuInstanceGetComputeInstancePossiblePlacements(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) ([]nvml.ComputeInstancePlacement, nvml.Return) {
|
|
if mock.GpuInstanceGetComputeInstancePossiblePlacementsFunc == nil {
|
|
panic("Interface.GpuInstanceGetComputeInstancePossiblePlacementsFunc: method is nil but Interface.GpuInstanceGetComputeInstancePossiblePlacements was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
}{
|
|
GpuInstance: gpuInstance,
|
|
ComputeInstanceProfileInfo: computeInstanceProfileInfo,
|
|
}
|
|
mock.lockGpuInstanceGetComputeInstancePossiblePlacements.Lock()
|
|
mock.calls.GpuInstanceGetComputeInstancePossiblePlacements = append(mock.calls.GpuInstanceGetComputeInstancePossiblePlacements, callInfo)
|
|
mock.lockGpuInstanceGetComputeInstancePossiblePlacements.Unlock()
|
|
return mock.GpuInstanceGetComputeInstancePossiblePlacementsFunc(gpuInstance, computeInstanceProfileInfo)
|
|
}
|
|
|
|
// GpuInstanceGetComputeInstancePossiblePlacementsCalls gets all the calls that were made to GpuInstanceGetComputeInstancePossiblePlacements.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpuInstanceGetComputeInstancePossiblePlacementsCalls())
|
|
func (mock *Interface) GpuInstanceGetComputeInstancePossiblePlacementsCalls() []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
} {
|
|
var calls []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
}
|
|
mock.lockGpuInstanceGetComputeInstancePossiblePlacements.RLock()
|
|
calls = mock.calls.GpuInstanceGetComputeInstancePossiblePlacements
|
|
mock.lockGpuInstanceGetComputeInstancePossiblePlacements.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpuInstanceGetComputeInstanceProfileInfo calls GpuInstanceGetComputeInstanceProfileInfoFunc.
|
|
func (mock *Interface) GpuInstanceGetComputeInstanceProfileInfo(gpuInstance nvml.GpuInstance, n1 int, n2 int) (nvml.ComputeInstanceProfileInfo, nvml.Return) {
|
|
if mock.GpuInstanceGetComputeInstanceProfileInfoFunc == nil {
|
|
panic("Interface.GpuInstanceGetComputeInstanceProfileInfoFunc: method is nil but Interface.GpuInstanceGetComputeInstanceProfileInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstance nvml.GpuInstance
|
|
N1 int
|
|
N2 int
|
|
}{
|
|
GpuInstance: gpuInstance,
|
|
N1: n1,
|
|
N2: n2,
|
|
}
|
|
mock.lockGpuInstanceGetComputeInstanceProfileInfo.Lock()
|
|
mock.calls.GpuInstanceGetComputeInstanceProfileInfo = append(mock.calls.GpuInstanceGetComputeInstanceProfileInfo, callInfo)
|
|
mock.lockGpuInstanceGetComputeInstanceProfileInfo.Unlock()
|
|
return mock.GpuInstanceGetComputeInstanceProfileInfoFunc(gpuInstance, n1, n2)
|
|
}
|
|
|
|
// GpuInstanceGetComputeInstanceProfileInfoCalls gets all the calls that were made to GpuInstanceGetComputeInstanceProfileInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpuInstanceGetComputeInstanceProfileInfoCalls())
|
|
func (mock *Interface) GpuInstanceGetComputeInstanceProfileInfoCalls() []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
N1 int
|
|
N2 int
|
|
} {
|
|
var calls []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
N1 int
|
|
N2 int
|
|
}
|
|
mock.lockGpuInstanceGetComputeInstanceProfileInfo.RLock()
|
|
calls = mock.calls.GpuInstanceGetComputeInstanceProfileInfo
|
|
mock.lockGpuInstanceGetComputeInstanceProfileInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpuInstanceGetComputeInstanceProfileInfoV calls GpuInstanceGetComputeInstanceProfileInfoVFunc.
|
|
func (mock *Interface) GpuInstanceGetComputeInstanceProfileInfoV(gpuInstance nvml.GpuInstance, n1 int, n2 int) nvml.ComputeInstanceProfileInfoV {
|
|
if mock.GpuInstanceGetComputeInstanceProfileInfoVFunc == nil {
|
|
panic("Interface.GpuInstanceGetComputeInstanceProfileInfoVFunc: method is nil but Interface.GpuInstanceGetComputeInstanceProfileInfoV was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstance nvml.GpuInstance
|
|
N1 int
|
|
N2 int
|
|
}{
|
|
GpuInstance: gpuInstance,
|
|
N1: n1,
|
|
N2: n2,
|
|
}
|
|
mock.lockGpuInstanceGetComputeInstanceProfileInfoV.Lock()
|
|
mock.calls.GpuInstanceGetComputeInstanceProfileInfoV = append(mock.calls.GpuInstanceGetComputeInstanceProfileInfoV, callInfo)
|
|
mock.lockGpuInstanceGetComputeInstanceProfileInfoV.Unlock()
|
|
return mock.GpuInstanceGetComputeInstanceProfileInfoVFunc(gpuInstance, n1, n2)
|
|
}
|
|
|
|
// GpuInstanceGetComputeInstanceProfileInfoVCalls gets all the calls that were made to GpuInstanceGetComputeInstanceProfileInfoV.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpuInstanceGetComputeInstanceProfileInfoVCalls())
|
|
func (mock *Interface) GpuInstanceGetComputeInstanceProfileInfoVCalls() []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
N1 int
|
|
N2 int
|
|
} {
|
|
var calls []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
N1 int
|
|
N2 int
|
|
}
|
|
mock.lockGpuInstanceGetComputeInstanceProfileInfoV.RLock()
|
|
calls = mock.calls.GpuInstanceGetComputeInstanceProfileInfoV
|
|
mock.lockGpuInstanceGetComputeInstanceProfileInfoV.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpuInstanceGetComputeInstanceRemainingCapacity calls GpuInstanceGetComputeInstanceRemainingCapacityFunc.
|
|
func (mock *Interface) GpuInstanceGetComputeInstanceRemainingCapacity(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) (int, nvml.Return) {
|
|
if mock.GpuInstanceGetComputeInstanceRemainingCapacityFunc == nil {
|
|
panic("Interface.GpuInstanceGetComputeInstanceRemainingCapacityFunc: method is nil but Interface.GpuInstanceGetComputeInstanceRemainingCapacity was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
}{
|
|
GpuInstance: gpuInstance,
|
|
ComputeInstanceProfileInfo: computeInstanceProfileInfo,
|
|
}
|
|
mock.lockGpuInstanceGetComputeInstanceRemainingCapacity.Lock()
|
|
mock.calls.GpuInstanceGetComputeInstanceRemainingCapacity = append(mock.calls.GpuInstanceGetComputeInstanceRemainingCapacity, callInfo)
|
|
mock.lockGpuInstanceGetComputeInstanceRemainingCapacity.Unlock()
|
|
return mock.GpuInstanceGetComputeInstanceRemainingCapacityFunc(gpuInstance, computeInstanceProfileInfo)
|
|
}
|
|
|
|
// GpuInstanceGetComputeInstanceRemainingCapacityCalls gets all the calls that were made to GpuInstanceGetComputeInstanceRemainingCapacity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpuInstanceGetComputeInstanceRemainingCapacityCalls())
|
|
func (mock *Interface) GpuInstanceGetComputeInstanceRemainingCapacityCalls() []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
} {
|
|
var calls []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
}
|
|
mock.lockGpuInstanceGetComputeInstanceRemainingCapacity.RLock()
|
|
calls = mock.calls.GpuInstanceGetComputeInstanceRemainingCapacity
|
|
mock.lockGpuInstanceGetComputeInstanceRemainingCapacity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpuInstanceGetComputeInstances calls GpuInstanceGetComputeInstancesFunc.
|
|
func (mock *Interface) GpuInstanceGetComputeInstances(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) ([]nvml.ComputeInstance, nvml.Return) {
|
|
if mock.GpuInstanceGetComputeInstancesFunc == nil {
|
|
panic("Interface.GpuInstanceGetComputeInstancesFunc: method is nil but Interface.GpuInstanceGetComputeInstances was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
}{
|
|
GpuInstance: gpuInstance,
|
|
ComputeInstanceProfileInfo: computeInstanceProfileInfo,
|
|
}
|
|
mock.lockGpuInstanceGetComputeInstances.Lock()
|
|
mock.calls.GpuInstanceGetComputeInstances = append(mock.calls.GpuInstanceGetComputeInstances, callInfo)
|
|
mock.lockGpuInstanceGetComputeInstances.Unlock()
|
|
return mock.GpuInstanceGetComputeInstancesFunc(gpuInstance, computeInstanceProfileInfo)
|
|
}
|
|
|
|
// GpuInstanceGetComputeInstancesCalls gets all the calls that were made to GpuInstanceGetComputeInstances.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpuInstanceGetComputeInstancesCalls())
|
|
func (mock *Interface) GpuInstanceGetComputeInstancesCalls() []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
} {
|
|
var calls []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
|
|
}
|
|
mock.lockGpuInstanceGetComputeInstances.RLock()
|
|
calls = mock.calls.GpuInstanceGetComputeInstances
|
|
mock.lockGpuInstanceGetComputeInstances.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpuInstanceGetInfo calls GpuInstanceGetInfoFunc.
|
|
func (mock *Interface) GpuInstanceGetInfo(gpuInstance nvml.GpuInstance) (nvml.GpuInstanceInfo, nvml.Return) {
|
|
if mock.GpuInstanceGetInfoFunc == nil {
|
|
panic("Interface.GpuInstanceGetInfoFunc: method is nil but Interface.GpuInstanceGetInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstance nvml.GpuInstance
|
|
}{
|
|
GpuInstance: gpuInstance,
|
|
}
|
|
mock.lockGpuInstanceGetInfo.Lock()
|
|
mock.calls.GpuInstanceGetInfo = append(mock.calls.GpuInstanceGetInfo, callInfo)
|
|
mock.lockGpuInstanceGetInfo.Unlock()
|
|
return mock.GpuInstanceGetInfoFunc(gpuInstance)
|
|
}
|
|
|
|
// GpuInstanceGetInfoCalls gets all the calls that were made to GpuInstanceGetInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.GpuInstanceGetInfoCalls())
|
|
func (mock *Interface) GpuInstanceGetInfoCalls() []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
} {
|
|
var calls []struct {
|
|
GpuInstance nvml.GpuInstance
|
|
}
|
|
mock.lockGpuInstanceGetInfo.RLock()
|
|
calls = mock.calls.GpuInstanceGetInfo
|
|
mock.lockGpuInstanceGetInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// Init calls InitFunc.
|
|
func (mock *Interface) Init() nvml.Return {
|
|
if mock.InitFunc == nil {
|
|
panic("Interface.InitFunc: method is nil but Interface.Init was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockInit.Lock()
|
|
mock.calls.Init = append(mock.calls.Init, callInfo)
|
|
mock.lockInit.Unlock()
|
|
return mock.InitFunc()
|
|
}
|
|
|
|
// InitCalls gets all the calls that were made to Init.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.InitCalls())
|
|
func (mock *Interface) InitCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockInit.RLock()
|
|
calls = mock.calls.Init
|
|
mock.lockInit.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// InitWithFlags calls InitWithFlagsFunc.
|
|
func (mock *Interface) InitWithFlags(v uint32) nvml.Return {
|
|
if mock.InitWithFlagsFunc == nil {
|
|
panic("Interface.InitWithFlagsFunc: method is nil but Interface.InitWithFlags was just called")
|
|
}
|
|
callInfo := struct {
|
|
V uint32
|
|
}{
|
|
V: v,
|
|
}
|
|
mock.lockInitWithFlags.Lock()
|
|
mock.calls.InitWithFlags = append(mock.calls.InitWithFlags, callInfo)
|
|
mock.lockInitWithFlags.Unlock()
|
|
return mock.InitWithFlagsFunc(v)
|
|
}
|
|
|
|
// InitWithFlagsCalls gets all the calls that were made to InitWithFlags.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.InitWithFlagsCalls())
|
|
func (mock *Interface) InitWithFlagsCalls() []struct {
|
|
V uint32
|
|
} {
|
|
var calls []struct {
|
|
V uint32
|
|
}
|
|
mock.lockInitWithFlags.RLock()
|
|
calls = mock.calls.InitWithFlags
|
|
mock.lockInitWithFlags.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetVgpuVersion calls SetVgpuVersionFunc.
|
|
func (mock *Interface) SetVgpuVersion(vgpuVersion *nvml.VgpuVersion) nvml.Return {
|
|
if mock.SetVgpuVersionFunc == nil {
|
|
panic("Interface.SetVgpuVersionFunc: method is nil but Interface.SetVgpuVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuVersion *nvml.VgpuVersion
|
|
}{
|
|
VgpuVersion: vgpuVersion,
|
|
}
|
|
mock.lockSetVgpuVersion.Lock()
|
|
mock.calls.SetVgpuVersion = append(mock.calls.SetVgpuVersion, callInfo)
|
|
mock.lockSetVgpuVersion.Unlock()
|
|
return mock.SetVgpuVersionFunc(vgpuVersion)
|
|
}
|
|
|
|
// SetVgpuVersionCalls gets all the calls that were made to SetVgpuVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.SetVgpuVersionCalls())
|
|
func (mock *Interface) SetVgpuVersionCalls() []struct {
|
|
VgpuVersion *nvml.VgpuVersion
|
|
} {
|
|
var calls []struct {
|
|
VgpuVersion *nvml.VgpuVersion
|
|
}
|
|
mock.lockSetVgpuVersion.RLock()
|
|
calls = mock.calls.SetVgpuVersion
|
|
mock.lockSetVgpuVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// Shutdown calls ShutdownFunc.
|
|
func (mock *Interface) Shutdown() nvml.Return {
|
|
if mock.ShutdownFunc == nil {
|
|
panic("Interface.ShutdownFunc: method is nil but Interface.Shutdown was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockShutdown.Lock()
|
|
mock.calls.Shutdown = append(mock.calls.Shutdown, callInfo)
|
|
mock.lockShutdown.Unlock()
|
|
return mock.ShutdownFunc()
|
|
}
|
|
|
|
// ShutdownCalls gets all the calls that were made to Shutdown.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.ShutdownCalls())
|
|
func (mock *Interface) ShutdownCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockShutdown.RLock()
|
|
calls = mock.calls.Shutdown
|
|
mock.lockShutdown.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SystemGetCudaDriverVersion calls SystemGetCudaDriverVersionFunc.
|
|
func (mock *Interface) SystemGetCudaDriverVersion() (int, nvml.Return) {
|
|
if mock.SystemGetCudaDriverVersionFunc == nil {
|
|
panic("Interface.SystemGetCudaDriverVersionFunc: method is nil but Interface.SystemGetCudaDriverVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockSystemGetCudaDriverVersion.Lock()
|
|
mock.calls.SystemGetCudaDriverVersion = append(mock.calls.SystemGetCudaDriverVersion, callInfo)
|
|
mock.lockSystemGetCudaDriverVersion.Unlock()
|
|
return mock.SystemGetCudaDriverVersionFunc()
|
|
}
|
|
|
|
// SystemGetCudaDriverVersionCalls gets all the calls that were made to SystemGetCudaDriverVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.SystemGetCudaDriverVersionCalls())
|
|
func (mock *Interface) SystemGetCudaDriverVersionCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockSystemGetCudaDriverVersion.RLock()
|
|
calls = mock.calls.SystemGetCudaDriverVersion
|
|
mock.lockSystemGetCudaDriverVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SystemGetCudaDriverVersion_v2 calls SystemGetCudaDriverVersion_v2Func.
|
|
func (mock *Interface) SystemGetCudaDriverVersion_v2() (int, nvml.Return) {
|
|
if mock.SystemGetCudaDriverVersion_v2Func == nil {
|
|
panic("Interface.SystemGetCudaDriverVersion_v2Func: method is nil but Interface.SystemGetCudaDriverVersion_v2 was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockSystemGetCudaDriverVersion_v2.Lock()
|
|
mock.calls.SystemGetCudaDriverVersion_v2 = append(mock.calls.SystemGetCudaDriverVersion_v2, callInfo)
|
|
mock.lockSystemGetCudaDriverVersion_v2.Unlock()
|
|
return mock.SystemGetCudaDriverVersion_v2Func()
|
|
}
|
|
|
|
// SystemGetCudaDriverVersion_v2Calls gets all the calls that were made to SystemGetCudaDriverVersion_v2.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.SystemGetCudaDriverVersion_v2Calls())
|
|
func (mock *Interface) SystemGetCudaDriverVersion_v2Calls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockSystemGetCudaDriverVersion_v2.RLock()
|
|
calls = mock.calls.SystemGetCudaDriverVersion_v2
|
|
mock.lockSystemGetCudaDriverVersion_v2.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SystemGetDriverVersion calls SystemGetDriverVersionFunc.
|
|
func (mock *Interface) SystemGetDriverVersion() (string, nvml.Return) {
|
|
if mock.SystemGetDriverVersionFunc == nil {
|
|
panic("Interface.SystemGetDriverVersionFunc: method is nil but Interface.SystemGetDriverVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockSystemGetDriverVersion.Lock()
|
|
mock.calls.SystemGetDriverVersion = append(mock.calls.SystemGetDriverVersion, callInfo)
|
|
mock.lockSystemGetDriverVersion.Unlock()
|
|
return mock.SystemGetDriverVersionFunc()
|
|
}
|
|
|
|
// SystemGetDriverVersionCalls gets all the calls that were made to SystemGetDriverVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.SystemGetDriverVersionCalls())
|
|
func (mock *Interface) SystemGetDriverVersionCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockSystemGetDriverVersion.RLock()
|
|
calls = mock.calls.SystemGetDriverVersion
|
|
mock.lockSystemGetDriverVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SystemGetHicVersion calls SystemGetHicVersionFunc.
|
|
func (mock *Interface) SystemGetHicVersion() ([]nvml.HwbcEntry, nvml.Return) {
|
|
if mock.SystemGetHicVersionFunc == nil {
|
|
panic("Interface.SystemGetHicVersionFunc: method is nil but Interface.SystemGetHicVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockSystemGetHicVersion.Lock()
|
|
mock.calls.SystemGetHicVersion = append(mock.calls.SystemGetHicVersion, callInfo)
|
|
mock.lockSystemGetHicVersion.Unlock()
|
|
return mock.SystemGetHicVersionFunc()
|
|
}
|
|
|
|
// SystemGetHicVersionCalls gets all the calls that were made to SystemGetHicVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.SystemGetHicVersionCalls())
|
|
func (mock *Interface) SystemGetHicVersionCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockSystemGetHicVersion.RLock()
|
|
calls = mock.calls.SystemGetHicVersion
|
|
mock.lockSystemGetHicVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SystemGetNVMLVersion calls SystemGetNVMLVersionFunc.
|
|
func (mock *Interface) SystemGetNVMLVersion() (string, nvml.Return) {
|
|
if mock.SystemGetNVMLVersionFunc == nil {
|
|
panic("Interface.SystemGetNVMLVersionFunc: method is nil but Interface.SystemGetNVMLVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockSystemGetNVMLVersion.Lock()
|
|
mock.calls.SystemGetNVMLVersion = append(mock.calls.SystemGetNVMLVersion, callInfo)
|
|
mock.lockSystemGetNVMLVersion.Unlock()
|
|
return mock.SystemGetNVMLVersionFunc()
|
|
}
|
|
|
|
// SystemGetNVMLVersionCalls gets all the calls that were made to SystemGetNVMLVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.SystemGetNVMLVersionCalls())
|
|
func (mock *Interface) SystemGetNVMLVersionCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockSystemGetNVMLVersion.RLock()
|
|
calls = mock.calls.SystemGetNVMLVersion
|
|
mock.lockSystemGetNVMLVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SystemGetProcessName calls SystemGetProcessNameFunc.
|
|
func (mock *Interface) SystemGetProcessName(n int) (string, nvml.Return) {
|
|
if mock.SystemGetProcessNameFunc == nil {
|
|
panic("Interface.SystemGetProcessNameFunc: method is nil but Interface.SystemGetProcessName was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockSystemGetProcessName.Lock()
|
|
mock.calls.SystemGetProcessName = append(mock.calls.SystemGetProcessName, callInfo)
|
|
mock.lockSystemGetProcessName.Unlock()
|
|
return mock.SystemGetProcessNameFunc(n)
|
|
}
|
|
|
|
// SystemGetProcessNameCalls gets all the calls that were made to SystemGetProcessName.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.SystemGetProcessNameCalls())
|
|
func (mock *Interface) SystemGetProcessNameCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockSystemGetProcessName.RLock()
|
|
calls = mock.calls.SystemGetProcessName
|
|
mock.lockSystemGetProcessName.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SystemGetTopologyGpuSet calls SystemGetTopologyGpuSetFunc.
|
|
func (mock *Interface) SystemGetTopologyGpuSet(n int) ([]nvml.Device, nvml.Return) {
|
|
if mock.SystemGetTopologyGpuSetFunc == nil {
|
|
panic("Interface.SystemGetTopologyGpuSetFunc: method is nil but Interface.SystemGetTopologyGpuSet was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockSystemGetTopologyGpuSet.Lock()
|
|
mock.calls.SystemGetTopologyGpuSet = append(mock.calls.SystemGetTopologyGpuSet, callInfo)
|
|
mock.lockSystemGetTopologyGpuSet.Unlock()
|
|
return mock.SystemGetTopologyGpuSetFunc(n)
|
|
}
|
|
|
|
// SystemGetTopologyGpuSetCalls gets all the calls that were made to SystemGetTopologyGpuSet.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.SystemGetTopologyGpuSetCalls())
|
|
func (mock *Interface) SystemGetTopologyGpuSetCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockSystemGetTopologyGpuSet.RLock()
|
|
calls = mock.calls.SystemGetTopologyGpuSet
|
|
mock.lockSystemGetTopologyGpuSet.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// UnitGetCount calls UnitGetCountFunc.
|
|
func (mock *Interface) UnitGetCount() (int, nvml.Return) {
|
|
if mock.UnitGetCountFunc == nil {
|
|
panic("Interface.UnitGetCountFunc: method is nil but Interface.UnitGetCount was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockUnitGetCount.Lock()
|
|
mock.calls.UnitGetCount = append(mock.calls.UnitGetCount, callInfo)
|
|
mock.lockUnitGetCount.Unlock()
|
|
return mock.UnitGetCountFunc()
|
|
}
|
|
|
|
// UnitGetCountCalls gets all the calls that were made to UnitGetCount.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.UnitGetCountCalls())
|
|
func (mock *Interface) UnitGetCountCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockUnitGetCount.RLock()
|
|
calls = mock.calls.UnitGetCount
|
|
mock.lockUnitGetCount.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// UnitGetDevices calls UnitGetDevicesFunc.
|
|
func (mock *Interface) UnitGetDevices(unit nvml.Unit) ([]nvml.Device, nvml.Return) {
|
|
if mock.UnitGetDevicesFunc == nil {
|
|
panic("Interface.UnitGetDevicesFunc: method is nil but Interface.UnitGetDevices was just called")
|
|
}
|
|
callInfo := struct {
|
|
Unit nvml.Unit
|
|
}{
|
|
Unit: unit,
|
|
}
|
|
mock.lockUnitGetDevices.Lock()
|
|
mock.calls.UnitGetDevices = append(mock.calls.UnitGetDevices, callInfo)
|
|
mock.lockUnitGetDevices.Unlock()
|
|
return mock.UnitGetDevicesFunc(unit)
|
|
}
|
|
|
|
// UnitGetDevicesCalls gets all the calls that were made to UnitGetDevices.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.UnitGetDevicesCalls())
|
|
func (mock *Interface) UnitGetDevicesCalls() []struct {
|
|
Unit nvml.Unit
|
|
} {
|
|
var calls []struct {
|
|
Unit nvml.Unit
|
|
}
|
|
mock.lockUnitGetDevices.RLock()
|
|
calls = mock.calls.UnitGetDevices
|
|
mock.lockUnitGetDevices.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// UnitGetFanSpeedInfo calls UnitGetFanSpeedInfoFunc.
|
|
func (mock *Interface) UnitGetFanSpeedInfo(unit nvml.Unit) (nvml.UnitFanSpeeds, nvml.Return) {
|
|
if mock.UnitGetFanSpeedInfoFunc == nil {
|
|
panic("Interface.UnitGetFanSpeedInfoFunc: method is nil but Interface.UnitGetFanSpeedInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
Unit nvml.Unit
|
|
}{
|
|
Unit: unit,
|
|
}
|
|
mock.lockUnitGetFanSpeedInfo.Lock()
|
|
mock.calls.UnitGetFanSpeedInfo = append(mock.calls.UnitGetFanSpeedInfo, callInfo)
|
|
mock.lockUnitGetFanSpeedInfo.Unlock()
|
|
return mock.UnitGetFanSpeedInfoFunc(unit)
|
|
}
|
|
|
|
// UnitGetFanSpeedInfoCalls gets all the calls that were made to UnitGetFanSpeedInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.UnitGetFanSpeedInfoCalls())
|
|
func (mock *Interface) UnitGetFanSpeedInfoCalls() []struct {
|
|
Unit nvml.Unit
|
|
} {
|
|
var calls []struct {
|
|
Unit nvml.Unit
|
|
}
|
|
mock.lockUnitGetFanSpeedInfo.RLock()
|
|
calls = mock.calls.UnitGetFanSpeedInfo
|
|
mock.lockUnitGetFanSpeedInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// UnitGetHandleByIndex calls UnitGetHandleByIndexFunc.
|
|
func (mock *Interface) UnitGetHandleByIndex(n int) (nvml.Unit, nvml.Return) {
|
|
if mock.UnitGetHandleByIndexFunc == nil {
|
|
panic("Interface.UnitGetHandleByIndexFunc: method is nil but Interface.UnitGetHandleByIndex was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockUnitGetHandleByIndex.Lock()
|
|
mock.calls.UnitGetHandleByIndex = append(mock.calls.UnitGetHandleByIndex, callInfo)
|
|
mock.lockUnitGetHandleByIndex.Unlock()
|
|
return mock.UnitGetHandleByIndexFunc(n)
|
|
}
|
|
|
|
// UnitGetHandleByIndexCalls gets all the calls that were made to UnitGetHandleByIndex.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.UnitGetHandleByIndexCalls())
|
|
func (mock *Interface) UnitGetHandleByIndexCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockUnitGetHandleByIndex.RLock()
|
|
calls = mock.calls.UnitGetHandleByIndex
|
|
mock.lockUnitGetHandleByIndex.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// UnitGetLedState calls UnitGetLedStateFunc.
|
|
func (mock *Interface) UnitGetLedState(unit nvml.Unit) (nvml.LedState, nvml.Return) {
|
|
if mock.UnitGetLedStateFunc == nil {
|
|
panic("Interface.UnitGetLedStateFunc: method is nil but Interface.UnitGetLedState was just called")
|
|
}
|
|
callInfo := struct {
|
|
Unit nvml.Unit
|
|
}{
|
|
Unit: unit,
|
|
}
|
|
mock.lockUnitGetLedState.Lock()
|
|
mock.calls.UnitGetLedState = append(mock.calls.UnitGetLedState, callInfo)
|
|
mock.lockUnitGetLedState.Unlock()
|
|
return mock.UnitGetLedStateFunc(unit)
|
|
}
|
|
|
|
// UnitGetLedStateCalls gets all the calls that were made to UnitGetLedState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.UnitGetLedStateCalls())
|
|
func (mock *Interface) UnitGetLedStateCalls() []struct {
|
|
Unit nvml.Unit
|
|
} {
|
|
var calls []struct {
|
|
Unit nvml.Unit
|
|
}
|
|
mock.lockUnitGetLedState.RLock()
|
|
calls = mock.calls.UnitGetLedState
|
|
mock.lockUnitGetLedState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// UnitGetPsuInfo calls UnitGetPsuInfoFunc.
|
|
func (mock *Interface) UnitGetPsuInfo(unit nvml.Unit) (nvml.PSUInfo, nvml.Return) {
|
|
if mock.UnitGetPsuInfoFunc == nil {
|
|
panic("Interface.UnitGetPsuInfoFunc: method is nil but Interface.UnitGetPsuInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
Unit nvml.Unit
|
|
}{
|
|
Unit: unit,
|
|
}
|
|
mock.lockUnitGetPsuInfo.Lock()
|
|
mock.calls.UnitGetPsuInfo = append(mock.calls.UnitGetPsuInfo, callInfo)
|
|
mock.lockUnitGetPsuInfo.Unlock()
|
|
return mock.UnitGetPsuInfoFunc(unit)
|
|
}
|
|
|
|
// UnitGetPsuInfoCalls gets all the calls that were made to UnitGetPsuInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.UnitGetPsuInfoCalls())
|
|
func (mock *Interface) UnitGetPsuInfoCalls() []struct {
|
|
Unit nvml.Unit
|
|
} {
|
|
var calls []struct {
|
|
Unit nvml.Unit
|
|
}
|
|
mock.lockUnitGetPsuInfo.RLock()
|
|
calls = mock.calls.UnitGetPsuInfo
|
|
mock.lockUnitGetPsuInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// UnitGetTemperature calls UnitGetTemperatureFunc.
|
|
func (mock *Interface) UnitGetTemperature(unit nvml.Unit, n int) (uint32, nvml.Return) {
|
|
if mock.UnitGetTemperatureFunc == nil {
|
|
panic("Interface.UnitGetTemperatureFunc: method is nil but Interface.UnitGetTemperature was just called")
|
|
}
|
|
callInfo := struct {
|
|
Unit nvml.Unit
|
|
N int
|
|
}{
|
|
Unit: unit,
|
|
N: n,
|
|
}
|
|
mock.lockUnitGetTemperature.Lock()
|
|
mock.calls.UnitGetTemperature = append(mock.calls.UnitGetTemperature, callInfo)
|
|
mock.lockUnitGetTemperature.Unlock()
|
|
return mock.UnitGetTemperatureFunc(unit, n)
|
|
}
|
|
|
|
// UnitGetTemperatureCalls gets all the calls that were made to UnitGetTemperature.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.UnitGetTemperatureCalls())
|
|
func (mock *Interface) UnitGetTemperatureCalls() []struct {
|
|
Unit nvml.Unit
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
Unit nvml.Unit
|
|
N int
|
|
}
|
|
mock.lockUnitGetTemperature.RLock()
|
|
calls = mock.calls.UnitGetTemperature
|
|
mock.lockUnitGetTemperature.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// UnitGetUnitInfo calls UnitGetUnitInfoFunc.
|
|
func (mock *Interface) UnitGetUnitInfo(unit nvml.Unit) (nvml.UnitInfo, nvml.Return) {
|
|
if mock.UnitGetUnitInfoFunc == nil {
|
|
panic("Interface.UnitGetUnitInfoFunc: method is nil but Interface.UnitGetUnitInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
Unit nvml.Unit
|
|
}{
|
|
Unit: unit,
|
|
}
|
|
mock.lockUnitGetUnitInfo.Lock()
|
|
mock.calls.UnitGetUnitInfo = append(mock.calls.UnitGetUnitInfo, callInfo)
|
|
mock.lockUnitGetUnitInfo.Unlock()
|
|
return mock.UnitGetUnitInfoFunc(unit)
|
|
}
|
|
|
|
// UnitGetUnitInfoCalls gets all the calls that were made to UnitGetUnitInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.UnitGetUnitInfoCalls())
|
|
func (mock *Interface) UnitGetUnitInfoCalls() []struct {
|
|
Unit nvml.Unit
|
|
} {
|
|
var calls []struct {
|
|
Unit nvml.Unit
|
|
}
|
|
mock.lockUnitGetUnitInfo.RLock()
|
|
calls = mock.calls.UnitGetUnitInfo
|
|
mock.lockUnitGetUnitInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// UnitSetLedState calls UnitSetLedStateFunc.
|
|
func (mock *Interface) UnitSetLedState(unit nvml.Unit, ledColor nvml.LedColor) nvml.Return {
|
|
if mock.UnitSetLedStateFunc == nil {
|
|
panic("Interface.UnitSetLedStateFunc: method is nil but Interface.UnitSetLedState was just called")
|
|
}
|
|
callInfo := struct {
|
|
Unit nvml.Unit
|
|
LedColor nvml.LedColor
|
|
}{
|
|
Unit: unit,
|
|
LedColor: ledColor,
|
|
}
|
|
mock.lockUnitSetLedState.Lock()
|
|
mock.calls.UnitSetLedState = append(mock.calls.UnitSetLedState, callInfo)
|
|
mock.lockUnitSetLedState.Unlock()
|
|
return mock.UnitSetLedStateFunc(unit, ledColor)
|
|
}
|
|
|
|
// UnitSetLedStateCalls gets all the calls that were made to UnitSetLedState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.UnitSetLedStateCalls())
|
|
func (mock *Interface) UnitSetLedStateCalls() []struct {
|
|
Unit nvml.Unit
|
|
LedColor nvml.LedColor
|
|
} {
|
|
var calls []struct {
|
|
Unit nvml.Unit
|
|
LedColor nvml.LedColor
|
|
}
|
|
mock.lockUnitSetLedState.RLock()
|
|
calls = mock.calls.UnitSetLedState
|
|
mock.lockUnitSetLedState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceClearAccountingPids calls VgpuInstanceClearAccountingPidsFunc.
|
|
func (mock *Interface) VgpuInstanceClearAccountingPids(vgpuInstance nvml.VgpuInstance) nvml.Return {
|
|
if mock.VgpuInstanceClearAccountingPidsFunc == nil {
|
|
panic("Interface.VgpuInstanceClearAccountingPidsFunc: method is nil but Interface.VgpuInstanceClearAccountingPids was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceClearAccountingPids.Lock()
|
|
mock.calls.VgpuInstanceClearAccountingPids = append(mock.calls.VgpuInstanceClearAccountingPids, callInfo)
|
|
mock.lockVgpuInstanceClearAccountingPids.Unlock()
|
|
return mock.VgpuInstanceClearAccountingPidsFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceClearAccountingPidsCalls gets all the calls that were made to VgpuInstanceClearAccountingPids.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceClearAccountingPidsCalls())
|
|
func (mock *Interface) VgpuInstanceClearAccountingPidsCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceClearAccountingPids.RLock()
|
|
calls = mock.calls.VgpuInstanceClearAccountingPids
|
|
mock.lockVgpuInstanceClearAccountingPids.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetAccountingMode calls VgpuInstanceGetAccountingModeFunc.
|
|
func (mock *Interface) VgpuInstanceGetAccountingMode(vgpuInstance nvml.VgpuInstance) (nvml.EnableState, nvml.Return) {
|
|
if mock.VgpuInstanceGetAccountingModeFunc == nil {
|
|
panic("Interface.VgpuInstanceGetAccountingModeFunc: method is nil but Interface.VgpuInstanceGetAccountingMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetAccountingMode.Lock()
|
|
mock.calls.VgpuInstanceGetAccountingMode = append(mock.calls.VgpuInstanceGetAccountingMode, callInfo)
|
|
mock.lockVgpuInstanceGetAccountingMode.Unlock()
|
|
return mock.VgpuInstanceGetAccountingModeFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetAccountingModeCalls gets all the calls that were made to VgpuInstanceGetAccountingMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetAccountingModeCalls())
|
|
func (mock *Interface) VgpuInstanceGetAccountingModeCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetAccountingMode.RLock()
|
|
calls = mock.calls.VgpuInstanceGetAccountingMode
|
|
mock.lockVgpuInstanceGetAccountingMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetAccountingPids calls VgpuInstanceGetAccountingPidsFunc.
|
|
func (mock *Interface) VgpuInstanceGetAccountingPids(vgpuInstance nvml.VgpuInstance) ([]int, nvml.Return) {
|
|
if mock.VgpuInstanceGetAccountingPidsFunc == nil {
|
|
panic("Interface.VgpuInstanceGetAccountingPidsFunc: method is nil but Interface.VgpuInstanceGetAccountingPids was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetAccountingPids.Lock()
|
|
mock.calls.VgpuInstanceGetAccountingPids = append(mock.calls.VgpuInstanceGetAccountingPids, callInfo)
|
|
mock.lockVgpuInstanceGetAccountingPids.Unlock()
|
|
return mock.VgpuInstanceGetAccountingPidsFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetAccountingPidsCalls gets all the calls that were made to VgpuInstanceGetAccountingPids.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetAccountingPidsCalls())
|
|
func (mock *Interface) VgpuInstanceGetAccountingPidsCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetAccountingPids.RLock()
|
|
calls = mock.calls.VgpuInstanceGetAccountingPids
|
|
mock.lockVgpuInstanceGetAccountingPids.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetAccountingStats calls VgpuInstanceGetAccountingStatsFunc.
|
|
func (mock *Interface) VgpuInstanceGetAccountingStats(vgpuInstance nvml.VgpuInstance, n int) (nvml.AccountingStats, nvml.Return) {
|
|
if mock.VgpuInstanceGetAccountingStatsFunc == nil {
|
|
panic("Interface.VgpuInstanceGetAccountingStatsFunc: method is nil but Interface.VgpuInstanceGetAccountingStats was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
N int
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
N: n,
|
|
}
|
|
mock.lockVgpuInstanceGetAccountingStats.Lock()
|
|
mock.calls.VgpuInstanceGetAccountingStats = append(mock.calls.VgpuInstanceGetAccountingStats, callInfo)
|
|
mock.lockVgpuInstanceGetAccountingStats.Unlock()
|
|
return mock.VgpuInstanceGetAccountingStatsFunc(vgpuInstance, n)
|
|
}
|
|
|
|
// VgpuInstanceGetAccountingStatsCalls gets all the calls that were made to VgpuInstanceGetAccountingStats.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetAccountingStatsCalls())
|
|
func (mock *Interface) VgpuInstanceGetAccountingStatsCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
N int
|
|
}
|
|
mock.lockVgpuInstanceGetAccountingStats.RLock()
|
|
calls = mock.calls.VgpuInstanceGetAccountingStats
|
|
mock.lockVgpuInstanceGetAccountingStats.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetEccMode calls VgpuInstanceGetEccModeFunc.
|
|
func (mock *Interface) VgpuInstanceGetEccMode(vgpuInstance nvml.VgpuInstance) (nvml.EnableState, nvml.Return) {
|
|
if mock.VgpuInstanceGetEccModeFunc == nil {
|
|
panic("Interface.VgpuInstanceGetEccModeFunc: method is nil but Interface.VgpuInstanceGetEccMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetEccMode.Lock()
|
|
mock.calls.VgpuInstanceGetEccMode = append(mock.calls.VgpuInstanceGetEccMode, callInfo)
|
|
mock.lockVgpuInstanceGetEccMode.Unlock()
|
|
return mock.VgpuInstanceGetEccModeFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetEccModeCalls gets all the calls that were made to VgpuInstanceGetEccMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetEccModeCalls())
|
|
func (mock *Interface) VgpuInstanceGetEccModeCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetEccMode.RLock()
|
|
calls = mock.calls.VgpuInstanceGetEccMode
|
|
mock.lockVgpuInstanceGetEccMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetEncoderCapacity calls VgpuInstanceGetEncoderCapacityFunc.
|
|
func (mock *Interface) VgpuInstanceGetEncoderCapacity(vgpuInstance nvml.VgpuInstance) (int, nvml.Return) {
|
|
if mock.VgpuInstanceGetEncoderCapacityFunc == nil {
|
|
panic("Interface.VgpuInstanceGetEncoderCapacityFunc: method is nil but Interface.VgpuInstanceGetEncoderCapacity was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetEncoderCapacity.Lock()
|
|
mock.calls.VgpuInstanceGetEncoderCapacity = append(mock.calls.VgpuInstanceGetEncoderCapacity, callInfo)
|
|
mock.lockVgpuInstanceGetEncoderCapacity.Unlock()
|
|
return mock.VgpuInstanceGetEncoderCapacityFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetEncoderCapacityCalls gets all the calls that were made to VgpuInstanceGetEncoderCapacity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetEncoderCapacityCalls())
|
|
func (mock *Interface) VgpuInstanceGetEncoderCapacityCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetEncoderCapacity.RLock()
|
|
calls = mock.calls.VgpuInstanceGetEncoderCapacity
|
|
mock.lockVgpuInstanceGetEncoderCapacity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetEncoderSessions calls VgpuInstanceGetEncoderSessionsFunc.
|
|
func (mock *Interface) VgpuInstanceGetEncoderSessions(vgpuInstance nvml.VgpuInstance) (int, nvml.EncoderSessionInfo, nvml.Return) {
|
|
if mock.VgpuInstanceGetEncoderSessionsFunc == nil {
|
|
panic("Interface.VgpuInstanceGetEncoderSessionsFunc: method is nil but Interface.VgpuInstanceGetEncoderSessions was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetEncoderSessions.Lock()
|
|
mock.calls.VgpuInstanceGetEncoderSessions = append(mock.calls.VgpuInstanceGetEncoderSessions, callInfo)
|
|
mock.lockVgpuInstanceGetEncoderSessions.Unlock()
|
|
return mock.VgpuInstanceGetEncoderSessionsFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetEncoderSessionsCalls gets all the calls that were made to VgpuInstanceGetEncoderSessions.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetEncoderSessionsCalls())
|
|
func (mock *Interface) VgpuInstanceGetEncoderSessionsCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetEncoderSessions.RLock()
|
|
calls = mock.calls.VgpuInstanceGetEncoderSessions
|
|
mock.lockVgpuInstanceGetEncoderSessions.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetEncoderStats calls VgpuInstanceGetEncoderStatsFunc.
|
|
func (mock *Interface) VgpuInstanceGetEncoderStats(vgpuInstance nvml.VgpuInstance) (int, uint32, uint32, nvml.Return) {
|
|
if mock.VgpuInstanceGetEncoderStatsFunc == nil {
|
|
panic("Interface.VgpuInstanceGetEncoderStatsFunc: method is nil but Interface.VgpuInstanceGetEncoderStats was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetEncoderStats.Lock()
|
|
mock.calls.VgpuInstanceGetEncoderStats = append(mock.calls.VgpuInstanceGetEncoderStats, callInfo)
|
|
mock.lockVgpuInstanceGetEncoderStats.Unlock()
|
|
return mock.VgpuInstanceGetEncoderStatsFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetEncoderStatsCalls gets all the calls that were made to VgpuInstanceGetEncoderStats.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetEncoderStatsCalls())
|
|
func (mock *Interface) VgpuInstanceGetEncoderStatsCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetEncoderStats.RLock()
|
|
calls = mock.calls.VgpuInstanceGetEncoderStats
|
|
mock.lockVgpuInstanceGetEncoderStats.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetFBCSessions calls VgpuInstanceGetFBCSessionsFunc.
|
|
func (mock *Interface) VgpuInstanceGetFBCSessions(vgpuInstance nvml.VgpuInstance) (int, nvml.FBCSessionInfo, nvml.Return) {
|
|
if mock.VgpuInstanceGetFBCSessionsFunc == nil {
|
|
panic("Interface.VgpuInstanceGetFBCSessionsFunc: method is nil but Interface.VgpuInstanceGetFBCSessions was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetFBCSessions.Lock()
|
|
mock.calls.VgpuInstanceGetFBCSessions = append(mock.calls.VgpuInstanceGetFBCSessions, callInfo)
|
|
mock.lockVgpuInstanceGetFBCSessions.Unlock()
|
|
return mock.VgpuInstanceGetFBCSessionsFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetFBCSessionsCalls gets all the calls that were made to VgpuInstanceGetFBCSessions.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetFBCSessionsCalls())
|
|
func (mock *Interface) VgpuInstanceGetFBCSessionsCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetFBCSessions.RLock()
|
|
calls = mock.calls.VgpuInstanceGetFBCSessions
|
|
mock.lockVgpuInstanceGetFBCSessions.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetFBCStats calls VgpuInstanceGetFBCStatsFunc.
|
|
func (mock *Interface) VgpuInstanceGetFBCStats(vgpuInstance nvml.VgpuInstance) (nvml.FBCStats, nvml.Return) {
|
|
if mock.VgpuInstanceGetFBCStatsFunc == nil {
|
|
panic("Interface.VgpuInstanceGetFBCStatsFunc: method is nil but Interface.VgpuInstanceGetFBCStats was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetFBCStats.Lock()
|
|
mock.calls.VgpuInstanceGetFBCStats = append(mock.calls.VgpuInstanceGetFBCStats, callInfo)
|
|
mock.lockVgpuInstanceGetFBCStats.Unlock()
|
|
return mock.VgpuInstanceGetFBCStatsFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetFBCStatsCalls gets all the calls that were made to VgpuInstanceGetFBCStats.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetFBCStatsCalls())
|
|
func (mock *Interface) VgpuInstanceGetFBCStatsCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetFBCStats.RLock()
|
|
calls = mock.calls.VgpuInstanceGetFBCStats
|
|
mock.lockVgpuInstanceGetFBCStats.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetFbUsage calls VgpuInstanceGetFbUsageFunc.
|
|
func (mock *Interface) VgpuInstanceGetFbUsage(vgpuInstance nvml.VgpuInstance) (uint64, nvml.Return) {
|
|
if mock.VgpuInstanceGetFbUsageFunc == nil {
|
|
panic("Interface.VgpuInstanceGetFbUsageFunc: method is nil but Interface.VgpuInstanceGetFbUsage was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetFbUsage.Lock()
|
|
mock.calls.VgpuInstanceGetFbUsage = append(mock.calls.VgpuInstanceGetFbUsage, callInfo)
|
|
mock.lockVgpuInstanceGetFbUsage.Unlock()
|
|
return mock.VgpuInstanceGetFbUsageFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetFbUsageCalls gets all the calls that were made to VgpuInstanceGetFbUsage.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetFbUsageCalls())
|
|
func (mock *Interface) VgpuInstanceGetFbUsageCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetFbUsage.RLock()
|
|
calls = mock.calls.VgpuInstanceGetFbUsage
|
|
mock.lockVgpuInstanceGetFbUsage.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetFrameRateLimit calls VgpuInstanceGetFrameRateLimitFunc.
|
|
func (mock *Interface) VgpuInstanceGetFrameRateLimit(vgpuInstance nvml.VgpuInstance) (uint32, nvml.Return) {
|
|
if mock.VgpuInstanceGetFrameRateLimitFunc == nil {
|
|
panic("Interface.VgpuInstanceGetFrameRateLimitFunc: method is nil but Interface.VgpuInstanceGetFrameRateLimit was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetFrameRateLimit.Lock()
|
|
mock.calls.VgpuInstanceGetFrameRateLimit = append(mock.calls.VgpuInstanceGetFrameRateLimit, callInfo)
|
|
mock.lockVgpuInstanceGetFrameRateLimit.Unlock()
|
|
return mock.VgpuInstanceGetFrameRateLimitFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetFrameRateLimitCalls gets all the calls that were made to VgpuInstanceGetFrameRateLimit.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetFrameRateLimitCalls())
|
|
func (mock *Interface) VgpuInstanceGetFrameRateLimitCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetFrameRateLimit.RLock()
|
|
calls = mock.calls.VgpuInstanceGetFrameRateLimit
|
|
mock.lockVgpuInstanceGetFrameRateLimit.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetGpuInstanceId calls VgpuInstanceGetGpuInstanceIdFunc.
|
|
func (mock *Interface) VgpuInstanceGetGpuInstanceId(vgpuInstance nvml.VgpuInstance) (int, nvml.Return) {
|
|
if mock.VgpuInstanceGetGpuInstanceIdFunc == nil {
|
|
panic("Interface.VgpuInstanceGetGpuInstanceIdFunc: method is nil but Interface.VgpuInstanceGetGpuInstanceId was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetGpuInstanceId.Lock()
|
|
mock.calls.VgpuInstanceGetGpuInstanceId = append(mock.calls.VgpuInstanceGetGpuInstanceId, callInfo)
|
|
mock.lockVgpuInstanceGetGpuInstanceId.Unlock()
|
|
return mock.VgpuInstanceGetGpuInstanceIdFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetGpuInstanceIdCalls gets all the calls that were made to VgpuInstanceGetGpuInstanceId.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetGpuInstanceIdCalls())
|
|
func (mock *Interface) VgpuInstanceGetGpuInstanceIdCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetGpuInstanceId.RLock()
|
|
calls = mock.calls.VgpuInstanceGetGpuInstanceId
|
|
mock.lockVgpuInstanceGetGpuInstanceId.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetGpuPciId calls VgpuInstanceGetGpuPciIdFunc.
|
|
func (mock *Interface) VgpuInstanceGetGpuPciId(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
|
|
if mock.VgpuInstanceGetGpuPciIdFunc == nil {
|
|
panic("Interface.VgpuInstanceGetGpuPciIdFunc: method is nil but Interface.VgpuInstanceGetGpuPciId was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetGpuPciId.Lock()
|
|
mock.calls.VgpuInstanceGetGpuPciId = append(mock.calls.VgpuInstanceGetGpuPciId, callInfo)
|
|
mock.lockVgpuInstanceGetGpuPciId.Unlock()
|
|
return mock.VgpuInstanceGetGpuPciIdFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetGpuPciIdCalls gets all the calls that were made to VgpuInstanceGetGpuPciId.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetGpuPciIdCalls())
|
|
func (mock *Interface) VgpuInstanceGetGpuPciIdCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetGpuPciId.RLock()
|
|
calls = mock.calls.VgpuInstanceGetGpuPciId
|
|
mock.lockVgpuInstanceGetGpuPciId.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetLicenseInfo calls VgpuInstanceGetLicenseInfoFunc.
|
|
func (mock *Interface) VgpuInstanceGetLicenseInfo(vgpuInstance nvml.VgpuInstance) (nvml.VgpuLicenseInfo, nvml.Return) {
|
|
if mock.VgpuInstanceGetLicenseInfoFunc == nil {
|
|
panic("Interface.VgpuInstanceGetLicenseInfoFunc: method is nil but Interface.VgpuInstanceGetLicenseInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetLicenseInfo.Lock()
|
|
mock.calls.VgpuInstanceGetLicenseInfo = append(mock.calls.VgpuInstanceGetLicenseInfo, callInfo)
|
|
mock.lockVgpuInstanceGetLicenseInfo.Unlock()
|
|
return mock.VgpuInstanceGetLicenseInfoFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetLicenseInfoCalls gets all the calls that were made to VgpuInstanceGetLicenseInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetLicenseInfoCalls())
|
|
func (mock *Interface) VgpuInstanceGetLicenseInfoCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetLicenseInfo.RLock()
|
|
calls = mock.calls.VgpuInstanceGetLicenseInfo
|
|
mock.lockVgpuInstanceGetLicenseInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetLicenseStatus calls VgpuInstanceGetLicenseStatusFunc.
|
|
func (mock *Interface) VgpuInstanceGetLicenseStatus(vgpuInstance nvml.VgpuInstance) (int, nvml.Return) {
|
|
if mock.VgpuInstanceGetLicenseStatusFunc == nil {
|
|
panic("Interface.VgpuInstanceGetLicenseStatusFunc: method is nil but Interface.VgpuInstanceGetLicenseStatus was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetLicenseStatus.Lock()
|
|
mock.calls.VgpuInstanceGetLicenseStatus = append(mock.calls.VgpuInstanceGetLicenseStatus, callInfo)
|
|
mock.lockVgpuInstanceGetLicenseStatus.Unlock()
|
|
return mock.VgpuInstanceGetLicenseStatusFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetLicenseStatusCalls gets all the calls that were made to VgpuInstanceGetLicenseStatus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetLicenseStatusCalls())
|
|
func (mock *Interface) VgpuInstanceGetLicenseStatusCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetLicenseStatus.RLock()
|
|
calls = mock.calls.VgpuInstanceGetLicenseStatus
|
|
mock.lockVgpuInstanceGetLicenseStatus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetMdevUUID calls VgpuInstanceGetMdevUUIDFunc.
|
|
func (mock *Interface) VgpuInstanceGetMdevUUID(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
|
|
if mock.VgpuInstanceGetMdevUUIDFunc == nil {
|
|
panic("Interface.VgpuInstanceGetMdevUUIDFunc: method is nil but Interface.VgpuInstanceGetMdevUUID was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetMdevUUID.Lock()
|
|
mock.calls.VgpuInstanceGetMdevUUID = append(mock.calls.VgpuInstanceGetMdevUUID, callInfo)
|
|
mock.lockVgpuInstanceGetMdevUUID.Unlock()
|
|
return mock.VgpuInstanceGetMdevUUIDFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetMdevUUIDCalls gets all the calls that were made to VgpuInstanceGetMdevUUID.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetMdevUUIDCalls())
|
|
func (mock *Interface) VgpuInstanceGetMdevUUIDCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetMdevUUID.RLock()
|
|
calls = mock.calls.VgpuInstanceGetMdevUUID
|
|
mock.lockVgpuInstanceGetMdevUUID.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetMetadata calls VgpuInstanceGetMetadataFunc.
|
|
func (mock *Interface) VgpuInstanceGetMetadata(vgpuInstance nvml.VgpuInstance) (nvml.VgpuMetadata, nvml.Return) {
|
|
if mock.VgpuInstanceGetMetadataFunc == nil {
|
|
panic("Interface.VgpuInstanceGetMetadataFunc: method is nil but Interface.VgpuInstanceGetMetadata was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetMetadata.Lock()
|
|
mock.calls.VgpuInstanceGetMetadata = append(mock.calls.VgpuInstanceGetMetadata, callInfo)
|
|
mock.lockVgpuInstanceGetMetadata.Unlock()
|
|
return mock.VgpuInstanceGetMetadataFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetMetadataCalls gets all the calls that were made to VgpuInstanceGetMetadata.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetMetadataCalls())
|
|
func (mock *Interface) VgpuInstanceGetMetadataCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetMetadata.RLock()
|
|
calls = mock.calls.VgpuInstanceGetMetadata
|
|
mock.lockVgpuInstanceGetMetadata.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetType calls VgpuInstanceGetTypeFunc.
|
|
func (mock *Interface) VgpuInstanceGetType(vgpuInstance nvml.VgpuInstance) (nvml.VgpuTypeId, nvml.Return) {
|
|
if mock.VgpuInstanceGetTypeFunc == nil {
|
|
panic("Interface.VgpuInstanceGetTypeFunc: method is nil but Interface.VgpuInstanceGetType was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetType.Lock()
|
|
mock.calls.VgpuInstanceGetType = append(mock.calls.VgpuInstanceGetType, callInfo)
|
|
mock.lockVgpuInstanceGetType.Unlock()
|
|
return mock.VgpuInstanceGetTypeFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetTypeCalls gets all the calls that were made to VgpuInstanceGetType.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetTypeCalls())
|
|
func (mock *Interface) VgpuInstanceGetTypeCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetType.RLock()
|
|
calls = mock.calls.VgpuInstanceGetType
|
|
mock.lockVgpuInstanceGetType.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetUUID calls VgpuInstanceGetUUIDFunc.
|
|
func (mock *Interface) VgpuInstanceGetUUID(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
|
|
if mock.VgpuInstanceGetUUIDFunc == nil {
|
|
panic("Interface.VgpuInstanceGetUUIDFunc: method is nil but Interface.VgpuInstanceGetUUID was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetUUID.Lock()
|
|
mock.calls.VgpuInstanceGetUUID = append(mock.calls.VgpuInstanceGetUUID, callInfo)
|
|
mock.lockVgpuInstanceGetUUID.Unlock()
|
|
return mock.VgpuInstanceGetUUIDFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetUUIDCalls gets all the calls that were made to VgpuInstanceGetUUID.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetUUIDCalls())
|
|
func (mock *Interface) VgpuInstanceGetUUIDCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetUUID.RLock()
|
|
calls = mock.calls.VgpuInstanceGetUUID
|
|
mock.lockVgpuInstanceGetUUID.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetVmDriverVersion calls VgpuInstanceGetVmDriverVersionFunc.
|
|
func (mock *Interface) VgpuInstanceGetVmDriverVersion(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
|
|
if mock.VgpuInstanceGetVmDriverVersionFunc == nil {
|
|
panic("Interface.VgpuInstanceGetVmDriverVersionFunc: method is nil but Interface.VgpuInstanceGetVmDriverVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetVmDriverVersion.Lock()
|
|
mock.calls.VgpuInstanceGetVmDriverVersion = append(mock.calls.VgpuInstanceGetVmDriverVersion, callInfo)
|
|
mock.lockVgpuInstanceGetVmDriverVersion.Unlock()
|
|
return mock.VgpuInstanceGetVmDriverVersionFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetVmDriverVersionCalls gets all the calls that were made to VgpuInstanceGetVmDriverVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetVmDriverVersionCalls())
|
|
func (mock *Interface) VgpuInstanceGetVmDriverVersionCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetVmDriverVersion.RLock()
|
|
calls = mock.calls.VgpuInstanceGetVmDriverVersion
|
|
mock.lockVgpuInstanceGetVmDriverVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceGetVmID calls VgpuInstanceGetVmIDFunc.
|
|
func (mock *Interface) VgpuInstanceGetVmID(vgpuInstance nvml.VgpuInstance) (string, nvml.VgpuVmIdType, nvml.Return) {
|
|
if mock.VgpuInstanceGetVmIDFunc == nil {
|
|
panic("Interface.VgpuInstanceGetVmIDFunc: method is nil but Interface.VgpuInstanceGetVmID was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
}
|
|
mock.lockVgpuInstanceGetVmID.Lock()
|
|
mock.calls.VgpuInstanceGetVmID = append(mock.calls.VgpuInstanceGetVmID, callInfo)
|
|
mock.lockVgpuInstanceGetVmID.Unlock()
|
|
return mock.VgpuInstanceGetVmIDFunc(vgpuInstance)
|
|
}
|
|
|
|
// VgpuInstanceGetVmIDCalls gets all the calls that were made to VgpuInstanceGetVmID.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceGetVmIDCalls())
|
|
func (mock *Interface) VgpuInstanceGetVmIDCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
}
|
|
mock.lockVgpuInstanceGetVmID.RLock()
|
|
calls = mock.calls.VgpuInstanceGetVmID
|
|
mock.lockVgpuInstanceGetVmID.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuInstanceSetEncoderCapacity calls VgpuInstanceSetEncoderCapacityFunc.
|
|
func (mock *Interface) VgpuInstanceSetEncoderCapacity(vgpuInstance nvml.VgpuInstance, n int) nvml.Return {
|
|
if mock.VgpuInstanceSetEncoderCapacityFunc == nil {
|
|
panic("Interface.VgpuInstanceSetEncoderCapacityFunc: method is nil but Interface.VgpuInstanceSetEncoderCapacity was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
N int
|
|
}{
|
|
VgpuInstance: vgpuInstance,
|
|
N: n,
|
|
}
|
|
mock.lockVgpuInstanceSetEncoderCapacity.Lock()
|
|
mock.calls.VgpuInstanceSetEncoderCapacity = append(mock.calls.VgpuInstanceSetEncoderCapacity, callInfo)
|
|
mock.lockVgpuInstanceSetEncoderCapacity.Unlock()
|
|
return mock.VgpuInstanceSetEncoderCapacityFunc(vgpuInstance, n)
|
|
}
|
|
|
|
// VgpuInstanceSetEncoderCapacityCalls gets all the calls that were made to VgpuInstanceSetEncoderCapacity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuInstanceSetEncoderCapacityCalls())
|
|
func (mock *Interface) VgpuInstanceSetEncoderCapacityCalls() []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
VgpuInstance nvml.VgpuInstance
|
|
N int
|
|
}
|
|
mock.lockVgpuInstanceSetEncoderCapacity.RLock()
|
|
calls = mock.calls.VgpuInstanceSetEncoderCapacity
|
|
mock.lockVgpuInstanceSetEncoderCapacity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuTypeGetCapabilities calls VgpuTypeGetCapabilitiesFunc.
|
|
func (mock *Interface) VgpuTypeGetCapabilities(vgpuTypeId nvml.VgpuTypeId, vgpuCapability nvml.VgpuCapability) (bool, nvml.Return) {
|
|
if mock.VgpuTypeGetCapabilitiesFunc == nil {
|
|
panic("Interface.VgpuTypeGetCapabilitiesFunc: method is nil but Interface.VgpuTypeGetCapabilities was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
VgpuCapability nvml.VgpuCapability
|
|
}{
|
|
VgpuTypeId: vgpuTypeId,
|
|
VgpuCapability: vgpuCapability,
|
|
}
|
|
mock.lockVgpuTypeGetCapabilities.Lock()
|
|
mock.calls.VgpuTypeGetCapabilities = append(mock.calls.VgpuTypeGetCapabilities, callInfo)
|
|
mock.lockVgpuTypeGetCapabilities.Unlock()
|
|
return mock.VgpuTypeGetCapabilitiesFunc(vgpuTypeId, vgpuCapability)
|
|
}
|
|
|
|
// VgpuTypeGetCapabilitiesCalls gets all the calls that were made to VgpuTypeGetCapabilities.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuTypeGetCapabilitiesCalls())
|
|
func (mock *Interface) VgpuTypeGetCapabilitiesCalls() []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
VgpuCapability nvml.VgpuCapability
|
|
} {
|
|
var calls []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
VgpuCapability nvml.VgpuCapability
|
|
}
|
|
mock.lockVgpuTypeGetCapabilities.RLock()
|
|
calls = mock.calls.VgpuTypeGetCapabilities
|
|
mock.lockVgpuTypeGetCapabilities.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuTypeGetClass calls VgpuTypeGetClassFunc.
|
|
func (mock *Interface) VgpuTypeGetClass(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return) {
|
|
if mock.VgpuTypeGetClassFunc == nil {
|
|
panic("Interface.VgpuTypeGetClassFunc: method is nil but Interface.VgpuTypeGetClass was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}{
|
|
VgpuTypeId: vgpuTypeId,
|
|
}
|
|
mock.lockVgpuTypeGetClass.Lock()
|
|
mock.calls.VgpuTypeGetClass = append(mock.calls.VgpuTypeGetClass, callInfo)
|
|
mock.lockVgpuTypeGetClass.Unlock()
|
|
return mock.VgpuTypeGetClassFunc(vgpuTypeId)
|
|
}
|
|
|
|
// VgpuTypeGetClassCalls gets all the calls that were made to VgpuTypeGetClass.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuTypeGetClassCalls())
|
|
func (mock *Interface) VgpuTypeGetClassCalls() []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
} {
|
|
var calls []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
mock.lockVgpuTypeGetClass.RLock()
|
|
calls = mock.calls.VgpuTypeGetClass
|
|
mock.lockVgpuTypeGetClass.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuTypeGetDeviceID calls VgpuTypeGetDeviceIDFunc.
|
|
func (mock *Interface) VgpuTypeGetDeviceID(vgpuTypeId nvml.VgpuTypeId) (uint64, uint64, nvml.Return) {
|
|
if mock.VgpuTypeGetDeviceIDFunc == nil {
|
|
panic("Interface.VgpuTypeGetDeviceIDFunc: method is nil but Interface.VgpuTypeGetDeviceID was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}{
|
|
VgpuTypeId: vgpuTypeId,
|
|
}
|
|
mock.lockVgpuTypeGetDeviceID.Lock()
|
|
mock.calls.VgpuTypeGetDeviceID = append(mock.calls.VgpuTypeGetDeviceID, callInfo)
|
|
mock.lockVgpuTypeGetDeviceID.Unlock()
|
|
return mock.VgpuTypeGetDeviceIDFunc(vgpuTypeId)
|
|
}
|
|
|
|
// VgpuTypeGetDeviceIDCalls gets all the calls that were made to VgpuTypeGetDeviceID.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuTypeGetDeviceIDCalls())
|
|
func (mock *Interface) VgpuTypeGetDeviceIDCalls() []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
} {
|
|
var calls []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
mock.lockVgpuTypeGetDeviceID.RLock()
|
|
calls = mock.calls.VgpuTypeGetDeviceID
|
|
mock.lockVgpuTypeGetDeviceID.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuTypeGetFrameRateLimit calls VgpuTypeGetFrameRateLimitFunc.
|
|
func (mock *Interface) VgpuTypeGetFrameRateLimit(vgpuTypeId nvml.VgpuTypeId) (uint32, nvml.Return) {
|
|
if mock.VgpuTypeGetFrameRateLimitFunc == nil {
|
|
panic("Interface.VgpuTypeGetFrameRateLimitFunc: method is nil but Interface.VgpuTypeGetFrameRateLimit was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}{
|
|
VgpuTypeId: vgpuTypeId,
|
|
}
|
|
mock.lockVgpuTypeGetFrameRateLimit.Lock()
|
|
mock.calls.VgpuTypeGetFrameRateLimit = append(mock.calls.VgpuTypeGetFrameRateLimit, callInfo)
|
|
mock.lockVgpuTypeGetFrameRateLimit.Unlock()
|
|
return mock.VgpuTypeGetFrameRateLimitFunc(vgpuTypeId)
|
|
}
|
|
|
|
// VgpuTypeGetFrameRateLimitCalls gets all the calls that were made to VgpuTypeGetFrameRateLimit.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuTypeGetFrameRateLimitCalls())
|
|
func (mock *Interface) VgpuTypeGetFrameRateLimitCalls() []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
} {
|
|
var calls []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
mock.lockVgpuTypeGetFrameRateLimit.RLock()
|
|
calls = mock.calls.VgpuTypeGetFrameRateLimit
|
|
mock.lockVgpuTypeGetFrameRateLimit.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuTypeGetFramebufferSize calls VgpuTypeGetFramebufferSizeFunc.
|
|
func (mock *Interface) VgpuTypeGetFramebufferSize(vgpuTypeId nvml.VgpuTypeId) (uint64, nvml.Return) {
|
|
if mock.VgpuTypeGetFramebufferSizeFunc == nil {
|
|
panic("Interface.VgpuTypeGetFramebufferSizeFunc: method is nil but Interface.VgpuTypeGetFramebufferSize was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}{
|
|
VgpuTypeId: vgpuTypeId,
|
|
}
|
|
mock.lockVgpuTypeGetFramebufferSize.Lock()
|
|
mock.calls.VgpuTypeGetFramebufferSize = append(mock.calls.VgpuTypeGetFramebufferSize, callInfo)
|
|
mock.lockVgpuTypeGetFramebufferSize.Unlock()
|
|
return mock.VgpuTypeGetFramebufferSizeFunc(vgpuTypeId)
|
|
}
|
|
|
|
// VgpuTypeGetFramebufferSizeCalls gets all the calls that were made to VgpuTypeGetFramebufferSize.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuTypeGetFramebufferSizeCalls())
|
|
func (mock *Interface) VgpuTypeGetFramebufferSizeCalls() []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
} {
|
|
var calls []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
mock.lockVgpuTypeGetFramebufferSize.RLock()
|
|
calls = mock.calls.VgpuTypeGetFramebufferSize
|
|
mock.lockVgpuTypeGetFramebufferSize.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuTypeGetGpuInstanceProfileId calls VgpuTypeGetGpuInstanceProfileIdFunc.
|
|
func (mock *Interface) VgpuTypeGetGpuInstanceProfileId(vgpuTypeId nvml.VgpuTypeId) (uint32, nvml.Return) {
|
|
if mock.VgpuTypeGetGpuInstanceProfileIdFunc == nil {
|
|
panic("Interface.VgpuTypeGetGpuInstanceProfileIdFunc: method is nil but Interface.VgpuTypeGetGpuInstanceProfileId was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}{
|
|
VgpuTypeId: vgpuTypeId,
|
|
}
|
|
mock.lockVgpuTypeGetGpuInstanceProfileId.Lock()
|
|
mock.calls.VgpuTypeGetGpuInstanceProfileId = append(mock.calls.VgpuTypeGetGpuInstanceProfileId, callInfo)
|
|
mock.lockVgpuTypeGetGpuInstanceProfileId.Unlock()
|
|
return mock.VgpuTypeGetGpuInstanceProfileIdFunc(vgpuTypeId)
|
|
}
|
|
|
|
// VgpuTypeGetGpuInstanceProfileIdCalls gets all the calls that were made to VgpuTypeGetGpuInstanceProfileId.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuTypeGetGpuInstanceProfileIdCalls())
|
|
func (mock *Interface) VgpuTypeGetGpuInstanceProfileIdCalls() []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
} {
|
|
var calls []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
mock.lockVgpuTypeGetGpuInstanceProfileId.RLock()
|
|
calls = mock.calls.VgpuTypeGetGpuInstanceProfileId
|
|
mock.lockVgpuTypeGetGpuInstanceProfileId.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuTypeGetLicense calls VgpuTypeGetLicenseFunc.
|
|
func (mock *Interface) VgpuTypeGetLicense(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return) {
|
|
if mock.VgpuTypeGetLicenseFunc == nil {
|
|
panic("Interface.VgpuTypeGetLicenseFunc: method is nil but Interface.VgpuTypeGetLicense was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}{
|
|
VgpuTypeId: vgpuTypeId,
|
|
}
|
|
mock.lockVgpuTypeGetLicense.Lock()
|
|
mock.calls.VgpuTypeGetLicense = append(mock.calls.VgpuTypeGetLicense, callInfo)
|
|
mock.lockVgpuTypeGetLicense.Unlock()
|
|
return mock.VgpuTypeGetLicenseFunc(vgpuTypeId)
|
|
}
|
|
|
|
// VgpuTypeGetLicenseCalls gets all the calls that were made to VgpuTypeGetLicense.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuTypeGetLicenseCalls())
|
|
func (mock *Interface) VgpuTypeGetLicenseCalls() []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
} {
|
|
var calls []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
mock.lockVgpuTypeGetLicense.RLock()
|
|
calls = mock.calls.VgpuTypeGetLicense
|
|
mock.lockVgpuTypeGetLicense.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuTypeGetMaxInstances calls VgpuTypeGetMaxInstancesFunc.
|
|
func (mock *Interface) VgpuTypeGetMaxInstances(device nvml.Device, vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
|
|
if mock.VgpuTypeGetMaxInstancesFunc == nil {
|
|
panic("Interface.VgpuTypeGetMaxInstancesFunc: method is nil but Interface.VgpuTypeGetMaxInstances was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}{
|
|
Device: device,
|
|
VgpuTypeId: vgpuTypeId,
|
|
}
|
|
mock.lockVgpuTypeGetMaxInstances.Lock()
|
|
mock.calls.VgpuTypeGetMaxInstances = append(mock.calls.VgpuTypeGetMaxInstances, callInfo)
|
|
mock.lockVgpuTypeGetMaxInstances.Unlock()
|
|
return mock.VgpuTypeGetMaxInstancesFunc(device, vgpuTypeId)
|
|
}
|
|
|
|
// VgpuTypeGetMaxInstancesCalls gets all the calls that were made to VgpuTypeGetMaxInstances.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuTypeGetMaxInstancesCalls())
|
|
func (mock *Interface) VgpuTypeGetMaxInstancesCalls() []struct {
|
|
Device nvml.Device
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
mock.lockVgpuTypeGetMaxInstances.RLock()
|
|
calls = mock.calls.VgpuTypeGetMaxInstances
|
|
mock.lockVgpuTypeGetMaxInstances.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuTypeGetMaxInstancesPerVm calls VgpuTypeGetMaxInstancesPerVmFunc.
|
|
func (mock *Interface) VgpuTypeGetMaxInstancesPerVm(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
|
|
if mock.VgpuTypeGetMaxInstancesPerVmFunc == nil {
|
|
panic("Interface.VgpuTypeGetMaxInstancesPerVmFunc: method is nil but Interface.VgpuTypeGetMaxInstancesPerVm was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}{
|
|
VgpuTypeId: vgpuTypeId,
|
|
}
|
|
mock.lockVgpuTypeGetMaxInstancesPerVm.Lock()
|
|
mock.calls.VgpuTypeGetMaxInstancesPerVm = append(mock.calls.VgpuTypeGetMaxInstancesPerVm, callInfo)
|
|
mock.lockVgpuTypeGetMaxInstancesPerVm.Unlock()
|
|
return mock.VgpuTypeGetMaxInstancesPerVmFunc(vgpuTypeId)
|
|
}
|
|
|
|
// VgpuTypeGetMaxInstancesPerVmCalls gets all the calls that were made to VgpuTypeGetMaxInstancesPerVm.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuTypeGetMaxInstancesPerVmCalls())
|
|
func (mock *Interface) VgpuTypeGetMaxInstancesPerVmCalls() []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
} {
|
|
var calls []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
mock.lockVgpuTypeGetMaxInstancesPerVm.RLock()
|
|
calls = mock.calls.VgpuTypeGetMaxInstancesPerVm
|
|
mock.lockVgpuTypeGetMaxInstancesPerVm.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuTypeGetName calls VgpuTypeGetNameFunc.
|
|
func (mock *Interface) VgpuTypeGetName(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return) {
|
|
if mock.VgpuTypeGetNameFunc == nil {
|
|
panic("Interface.VgpuTypeGetNameFunc: method is nil but Interface.VgpuTypeGetName was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}{
|
|
VgpuTypeId: vgpuTypeId,
|
|
}
|
|
mock.lockVgpuTypeGetName.Lock()
|
|
mock.calls.VgpuTypeGetName = append(mock.calls.VgpuTypeGetName, callInfo)
|
|
mock.lockVgpuTypeGetName.Unlock()
|
|
return mock.VgpuTypeGetNameFunc(vgpuTypeId)
|
|
}
|
|
|
|
// VgpuTypeGetNameCalls gets all the calls that were made to VgpuTypeGetName.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuTypeGetNameCalls())
|
|
func (mock *Interface) VgpuTypeGetNameCalls() []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
} {
|
|
var calls []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
mock.lockVgpuTypeGetName.RLock()
|
|
calls = mock.calls.VgpuTypeGetName
|
|
mock.lockVgpuTypeGetName.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuTypeGetNumDisplayHeads calls VgpuTypeGetNumDisplayHeadsFunc.
|
|
func (mock *Interface) VgpuTypeGetNumDisplayHeads(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
|
|
if mock.VgpuTypeGetNumDisplayHeadsFunc == nil {
|
|
panic("Interface.VgpuTypeGetNumDisplayHeadsFunc: method is nil but Interface.VgpuTypeGetNumDisplayHeads was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}{
|
|
VgpuTypeId: vgpuTypeId,
|
|
}
|
|
mock.lockVgpuTypeGetNumDisplayHeads.Lock()
|
|
mock.calls.VgpuTypeGetNumDisplayHeads = append(mock.calls.VgpuTypeGetNumDisplayHeads, callInfo)
|
|
mock.lockVgpuTypeGetNumDisplayHeads.Unlock()
|
|
return mock.VgpuTypeGetNumDisplayHeadsFunc(vgpuTypeId)
|
|
}
|
|
|
|
// VgpuTypeGetNumDisplayHeadsCalls gets all the calls that were made to VgpuTypeGetNumDisplayHeads.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuTypeGetNumDisplayHeadsCalls())
|
|
func (mock *Interface) VgpuTypeGetNumDisplayHeadsCalls() []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
} {
|
|
var calls []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
mock.lockVgpuTypeGetNumDisplayHeads.RLock()
|
|
calls = mock.calls.VgpuTypeGetNumDisplayHeads
|
|
mock.lockVgpuTypeGetNumDisplayHeads.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuTypeGetResolution calls VgpuTypeGetResolutionFunc.
|
|
func (mock *Interface) VgpuTypeGetResolution(vgpuTypeId nvml.VgpuTypeId, n int) (uint32, uint32, nvml.Return) {
|
|
if mock.VgpuTypeGetResolutionFunc == nil {
|
|
panic("Interface.VgpuTypeGetResolutionFunc: method is nil but Interface.VgpuTypeGetResolution was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
N int
|
|
}{
|
|
VgpuTypeId: vgpuTypeId,
|
|
N: n,
|
|
}
|
|
mock.lockVgpuTypeGetResolution.Lock()
|
|
mock.calls.VgpuTypeGetResolution = append(mock.calls.VgpuTypeGetResolution, callInfo)
|
|
mock.lockVgpuTypeGetResolution.Unlock()
|
|
return mock.VgpuTypeGetResolutionFunc(vgpuTypeId, n)
|
|
}
|
|
|
|
// VgpuTypeGetResolutionCalls gets all the calls that were made to VgpuTypeGetResolution.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedInterface.VgpuTypeGetResolutionCalls())
|
|
func (mock *Interface) VgpuTypeGetResolutionCalls() []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
N int
|
|
}
|
|
mock.lockVgpuTypeGetResolution.RLock()
|
|
calls = mock.calls.VgpuTypeGetResolution
|
|
mock.lockVgpuTypeGetResolution.RUnlock()
|
|
return calls
|
|
}
|