mirror of
https://github.com/NVIDIA/nvidia-container-toolkit
synced 2024-12-02 00:54:48 +00:00
8284 lines
288 KiB
Go
8284 lines
288 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 Device does implement nvml.Device.
|
|
// If this is not the case, regenerate this file with moq.
|
|
var _ nvml.Device = &Device{}
|
|
|
|
// Device is a mock implementation of nvml.Device.
|
|
//
|
|
// func TestSomethingThatUsesDevice(t *testing.T) {
|
|
//
|
|
// // make and configure a mocked nvml.Device
|
|
// mockedDevice := &Device{
|
|
// CcuGetStreamStateFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the CcuGetStreamState method")
|
|
// },
|
|
// CcuSetStreamStateFunc: func(n int) nvml.Return {
|
|
// panic("mock out the CcuSetStreamState method")
|
|
// },
|
|
// ClearAccountingPidsFunc: func() nvml.Return {
|
|
// panic("mock out the ClearAccountingPids method")
|
|
// },
|
|
// ClearCpuAffinityFunc: func() nvml.Return {
|
|
// panic("mock out the ClearCpuAffinity method")
|
|
// },
|
|
// ClearEccErrorCountsFunc: func(eccCounterType nvml.EccCounterType) nvml.Return {
|
|
// panic("mock out the ClearEccErrorCounts method")
|
|
// },
|
|
// ClearFieldValuesFunc: func(fieldValues []nvml.FieldValue) nvml.Return {
|
|
// panic("mock out the ClearFieldValues method")
|
|
// },
|
|
// CreateGpuInstanceFunc: func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (nvml.GpuInstance, nvml.Return) {
|
|
// panic("mock out the CreateGpuInstance method")
|
|
// },
|
|
// CreateGpuInstanceWithPlacementFunc: func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo, gpuInstancePlacement *nvml.GpuInstancePlacement) (nvml.GpuInstance, nvml.Return) {
|
|
// panic("mock out the CreateGpuInstanceWithPlacement method")
|
|
// },
|
|
// FreezeNvLinkUtilizationCounterFunc: func(n1 int, n2 int, enableState nvml.EnableState) nvml.Return {
|
|
// panic("mock out the FreezeNvLinkUtilizationCounter method")
|
|
// },
|
|
// GetAPIRestrictionFunc: func(restrictedAPI nvml.RestrictedAPI) (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the GetAPIRestriction method")
|
|
// },
|
|
// GetAccountingBufferSizeFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetAccountingBufferSize method")
|
|
// },
|
|
// GetAccountingModeFunc: func() (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the GetAccountingMode method")
|
|
// },
|
|
// GetAccountingPidsFunc: func() ([]int, nvml.Return) {
|
|
// panic("mock out the GetAccountingPids method")
|
|
// },
|
|
// GetAccountingStatsFunc: func(v uint32) (nvml.AccountingStats, nvml.Return) {
|
|
// panic("mock out the GetAccountingStats method")
|
|
// },
|
|
// GetActiveVgpusFunc: func() ([]nvml.VgpuInstance, nvml.Return) {
|
|
// panic("mock out the GetActiveVgpus method")
|
|
// },
|
|
// GetAdaptiveClockInfoStatusFunc: func() (uint32, nvml.Return) {
|
|
// panic("mock out the GetAdaptiveClockInfoStatus method")
|
|
// },
|
|
// GetApplicationsClockFunc: func(clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
// panic("mock out the GetApplicationsClock method")
|
|
// },
|
|
// GetArchitectureFunc: func() (nvml.DeviceArchitecture, nvml.Return) {
|
|
// panic("mock out the GetArchitecture method")
|
|
// },
|
|
// GetAttributesFunc: func() (nvml.DeviceAttributes, nvml.Return) {
|
|
// panic("mock out the GetAttributes method")
|
|
// },
|
|
// GetAutoBoostedClocksEnabledFunc: func() (nvml.EnableState, nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the GetAutoBoostedClocksEnabled method")
|
|
// },
|
|
// GetBAR1MemoryInfoFunc: func() (nvml.BAR1Memory, nvml.Return) {
|
|
// panic("mock out the GetBAR1MemoryInfo method")
|
|
// },
|
|
// GetBoardIdFunc: func() (uint32, nvml.Return) {
|
|
// panic("mock out the GetBoardId method")
|
|
// },
|
|
// GetBoardPartNumberFunc: func() (string, nvml.Return) {
|
|
// panic("mock out the GetBoardPartNumber method")
|
|
// },
|
|
// GetBrandFunc: func() (nvml.BrandType, nvml.Return) {
|
|
// panic("mock out the GetBrand method")
|
|
// },
|
|
// GetBridgeChipInfoFunc: func() (nvml.BridgeChipHierarchy, nvml.Return) {
|
|
// panic("mock out the GetBridgeChipInfo method")
|
|
// },
|
|
// GetBusTypeFunc: func() (nvml.BusType, nvml.Return) {
|
|
// panic("mock out the GetBusType method")
|
|
// },
|
|
// GetClkMonStatusFunc: func() (nvml.ClkMonStatus, nvml.Return) {
|
|
// panic("mock out the GetClkMonStatus method")
|
|
// },
|
|
// GetClockFunc: func(clockType nvml.ClockType, clockId nvml.ClockId) (uint32, nvml.Return) {
|
|
// panic("mock out the GetClock method")
|
|
// },
|
|
// GetClockInfoFunc: func(clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
// panic("mock out the GetClockInfo method")
|
|
// },
|
|
// GetComputeInstanceIdFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetComputeInstanceId method")
|
|
// },
|
|
// GetComputeModeFunc: func() (nvml.ComputeMode, nvml.Return) {
|
|
// panic("mock out the GetComputeMode method")
|
|
// },
|
|
// GetComputeRunningProcessesFunc: func() ([]nvml.ProcessInfo, nvml.Return) {
|
|
// panic("mock out the GetComputeRunningProcesses method")
|
|
// },
|
|
// GetCpuAffinityFunc: func(n int) ([]uint, nvml.Return) {
|
|
// panic("mock out the GetCpuAffinity method")
|
|
// },
|
|
// GetCpuAffinityWithinScopeFunc: func(n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return) {
|
|
// panic("mock out the GetCpuAffinityWithinScope method")
|
|
// },
|
|
// GetCreatableVgpusFunc: func() ([]nvml.VgpuTypeId, nvml.Return) {
|
|
// panic("mock out the GetCreatableVgpus method")
|
|
// },
|
|
// GetCudaComputeCapabilityFunc: func() (int, int, nvml.Return) {
|
|
// panic("mock out the GetCudaComputeCapability method")
|
|
// },
|
|
// GetCurrPcieLinkGenerationFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetCurrPcieLinkGeneration method")
|
|
// },
|
|
// GetCurrPcieLinkWidthFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetCurrPcieLinkWidth method")
|
|
// },
|
|
// GetCurrentClocksThrottleReasonsFunc: func() (uint64, nvml.Return) {
|
|
// panic("mock out the GetCurrentClocksThrottleReasons method")
|
|
// },
|
|
// GetDecoderUtilizationFunc: func() (uint32, uint32, nvml.Return) {
|
|
// panic("mock out the GetDecoderUtilization method")
|
|
// },
|
|
// GetDefaultApplicationsClockFunc: func(clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
// panic("mock out the GetDefaultApplicationsClock method")
|
|
// },
|
|
// GetDefaultEccModeFunc: func() (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the GetDefaultEccMode method")
|
|
// },
|
|
// GetDetailedEccErrorsFunc: func(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (nvml.EccErrorCounts, nvml.Return) {
|
|
// panic("mock out the GetDetailedEccErrors method")
|
|
// },
|
|
// GetDeviceHandleFromMigDeviceHandleFunc: func() (nvml.Device, nvml.Return) {
|
|
// panic("mock out the GetDeviceHandleFromMigDeviceHandle method")
|
|
// },
|
|
// GetDisplayActiveFunc: func() (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the GetDisplayActive method")
|
|
// },
|
|
// GetDisplayModeFunc: func() (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the GetDisplayMode method")
|
|
// },
|
|
// GetDriverModelFunc: func() (nvml.DriverModel, nvml.DriverModel, nvml.Return) {
|
|
// panic("mock out the GetDriverModel method")
|
|
// },
|
|
// GetDynamicPstatesInfoFunc: func() (nvml.GpuDynamicPstatesInfo, nvml.Return) {
|
|
// panic("mock out the GetDynamicPstatesInfo method")
|
|
// },
|
|
// GetEccModeFunc: func() (nvml.EnableState, nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the GetEccMode method")
|
|
// },
|
|
// GetEncoderCapacityFunc: func(encoderType nvml.EncoderType) (int, nvml.Return) {
|
|
// panic("mock out the GetEncoderCapacity method")
|
|
// },
|
|
// GetEncoderSessionsFunc: func() ([]nvml.EncoderSessionInfo, nvml.Return) {
|
|
// panic("mock out the GetEncoderSessions method")
|
|
// },
|
|
// GetEncoderStatsFunc: func() (int, uint32, uint32, nvml.Return) {
|
|
// panic("mock out the GetEncoderStats method")
|
|
// },
|
|
// GetEncoderUtilizationFunc: func() (uint32, uint32, nvml.Return) {
|
|
// panic("mock out the GetEncoderUtilization method")
|
|
// },
|
|
// GetEnforcedPowerLimitFunc: func() (uint32, nvml.Return) {
|
|
// panic("mock out the GetEnforcedPowerLimit method")
|
|
// },
|
|
// GetFBCSessionsFunc: func() ([]nvml.FBCSessionInfo, nvml.Return) {
|
|
// panic("mock out the GetFBCSessions method")
|
|
// },
|
|
// GetFBCStatsFunc: func() (nvml.FBCStats, nvml.Return) {
|
|
// panic("mock out the GetFBCStats method")
|
|
// },
|
|
// GetFanControlPolicy_v2Func: func(n int) (nvml.FanControlPolicy, nvml.Return) {
|
|
// panic("mock out the GetFanControlPolicy_v2 method")
|
|
// },
|
|
// GetFanSpeedFunc: func() (uint32, nvml.Return) {
|
|
// panic("mock out the GetFanSpeed method")
|
|
// },
|
|
// GetFanSpeed_v2Func: func(n int) (uint32, nvml.Return) {
|
|
// panic("mock out the GetFanSpeed_v2 method")
|
|
// },
|
|
// GetFieldValuesFunc: func(fieldValues []nvml.FieldValue) nvml.Return {
|
|
// panic("mock out the GetFieldValues method")
|
|
// },
|
|
// GetGpcClkMinMaxVfOffsetFunc: func() (int, int, nvml.Return) {
|
|
// panic("mock out the GetGpcClkMinMaxVfOffset method")
|
|
// },
|
|
// GetGpcClkVfOffsetFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetGpcClkVfOffset method")
|
|
// },
|
|
// GetGpuFabricInfoFunc: func() (nvml.GpuFabricInfo, nvml.Return) {
|
|
// panic("mock out the GetGpuFabricInfo method")
|
|
// },
|
|
// GetGpuInstanceByIdFunc: func(n int) (nvml.GpuInstance, nvml.Return) {
|
|
// panic("mock out the GetGpuInstanceById method")
|
|
// },
|
|
// GetGpuInstanceIdFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetGpuInstanceId method")
|
|
// },
|
|
// GetGpuInstancePossiblePlacementsFunc: func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstancePlacement, nvml.Return) {
|
|
// panic("mock out the GetGpuInstancePossiblePlacements method")
|
|
// },
|
|
// GetGpuInstanceProfileInfoFunc: func(n int) (nvml.GpuInstanceProfileInfo, nvml.Return) {
|
|
// panic("mock out the GetGpuInstanceProfileInfo method")
|
|
// },
|
|
// GetGpuInstanceProfileInfoVFunc: func(n int) nvml.GpuInstanceProfileInfoV {
|
|
// panic("mock out the GetGpuInstanceProfileInfoV method")
|
|
// },
|
|
// GetGpuInstanceRemainingCapacityFunc: func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (int, nvml.Return) {
|
|
// panic("mock out the GetGpuInstanceRemainingCapacity method")
|
|
// },
|
|
// GetGpuInstancesFunc: func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstance, nvml.Return) {
|
|
// panic("mock out the GetGpuInstances method")
|
|
// },
|
|
// GetGpuMaxPcieLinkGenerationFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetGpuMaxPcieLinkGeneration method")
|
|
// },
|
|
// GetGpuOperationModeFunc: func() (nvml.GpuOperationMode, nvml.GpuOperationMode, nvml.Return) {
|
|
// panic("mock out the GetGpuOperationMode method")
|
|
// },
|
|
// GetGraphicsRunningProcessesFunc: func() ([]nvml.ProcessInfo, nvml.Return) {
|
|
// panic("mock out the GetGraphicsRunningProcesses method")
|
|
// },
|
|
// GetGridLicensableFeaturesFunc: func() (nvml.GridLicensableFeatures, nvml.Return) {
|
|
// panic("mock out the GetGridLicensableFeatures method")
|
|
// },
|
|
// GetGspFirmwareModeFunc: func() (bool, bool, nvml.Return) {
|
|
// panic("mock out the GetGspFirmwareMode method")
|
|
// },
|
|
// GetGspFirmwareVersionFunc: func() (string, nvml.Return) {
|
|
// panic("mock out the GetGspFirmwareVersion method")
|
|
// },
|
|
// GetHostVgpuModeFunc: func() (nvml.HostVgpuMode, nvml.Return) {
|
|
// panic("mock out the GetHostVgpuMode method")
|
|
// },
|
|
// GetIndexFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetIndex method")
|
|
// },
|
|
// GetInforomConfigurationChecksumFunc: func() (uint32, nvml.Return) {
|
|
// panic("mock out the GetInforomConfigurationChecksum method")
|
|
// },
|
|
// GetInforomImageVersionFunc: func() (string, nvml.Return) {
|
|
// panic("mock out the GetInforomImageVersion method")
|
|
// },
|
|
// GetInforomVersionFunc: func(inforomObject nvml.InforomObject) (string, nvml.Return) {
|
|
// panic("mock out the GetInforomVersion method")
|
|
// },
|
|
// GetIrqNumFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetIrqNum method")
|
|
// },
|
|
// GetMPSComputeRunningProcessesFunc: func() ([]nvml.ProcessInfo, nvml.Return) {
|
|
// panic("mock out the GetMPSComputeRunningProcesses method")
|
|
// },
|
|
// GetMaxClockInfoFunc: func(clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
// panic("mock out the GetMaxClockInfo method")
|
|
// },
|
|
// GetMaxCustomerBoostClockFunc: func(clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
// panic("mock out the GetMaxCustomerBoostClock method")
|
|
// },
|
|
// GetMaxMigDeviceCountFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetMaxMigDeviceCount method")
|
|
// },
|
|
// GetMaxPcieLinkGenerationFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetMaxPcieLinkGeneration method")
|
|
// },
|
|
// GetMaxPcieLinkWidthFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetMaxPcieLinkWidth method")
|
|
// },
|
|
// GetMemClkMinMaxVfOffsetFunc: func() (int, int, nvml.Return) {
|
|
// panic("mock out the GetMemClkMinMaxVfOffset method")
|
|
// },
|
|
// GetMemClkVfOffsetFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetMemClkVfOffset method")
|
|
// },
|
|
// GetMemoryAffinityFunc: func(n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return) {
|
|
// panic("mock out the GetMemoryAffinity method")
|
|
// },
|
|
// GetMemoryBusWidthFunc: func() (uint32, nvml.Return) {
|
|
// panic("mock out the GetMemoryBusWidth method")
|
|
// },
|
|
// GetMemoryErrorCounterFunc: func(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType, memoryLocation nvml.MemoryLocation) (uint64, nvml.Return) {
|
|
// panic("mock out the GetMemoryErrorCounter method")
|
|
// },
|
|
// GetMemoryInfoFunc: func() (nvml.Memory, nvml.Return) {
|
|
// panic("mock out the GetMemoryInfo method")
|
|
// },
|
|
// GetMemoryInfo_v2Func: func() (nvml.Memory_v2, nvml.Return) {
|
|
// panic("mock out the GetMemoryInfo_v2 method")
|
|
// },
|
|
// GetMigDeviceHandleByIndexFunc: func(n int) (nvml.Device, nvml.Return) {
|
|
// panic("mock out the GetMigDeviceHandleByIndex method")
|
|
// },
|
|
// GetMigModeFunc: func() (int, int, nvml.Return) {
|
|
// panic("mock out the GetMigMode method")
|
|
// },
|
|
// GetMinMaxClockOfPStateFunc: func(clockType nvml.ClockType, pstates nvml.Pstates) (uint32, uint32, nvml.Return) {
|
|
// panic("mock out the GetMinMaxClockOfPState method")
|
|
// },
|
|
// GetMinMaxFanSpeedFunc: func() (int, int, nvml.Return) {
|
|
// panic("mock out the GetMinMaxFanSpeed method")
|
|
// },
|
|
// GetMinorNumberFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetMinorNumber method")
|
|
// },
|
|
// GetMultiGpuBoardFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetMultiGpuBoard method")
|
|
// },
|
|
// GetNameFunc: func() (string, nvml.Return) {
|
|
// panic("mock out the GetName method")
|
|
// },
|
|
// GetNumFansFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetNumFans method")
|
|
// },
|
|
// GetNumGpuCoresFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetNumGpuCores method")
|
|
// },
|
|
// GetNvLinkCapabilityFunc: func(n int, nvLinkCapability nvml.NvLinkCapability) (uint32, nvml.Return) {
|
|
// panic("mock out the GetNvLinkCapability method")
|
|
// },
|
|
// GetNvLinkErrorCounterFunc: func(n int, nvLinkErrorCounter nvml.NvLinkErrorCounter) (uint64, nvml.Return) {
|
|
// panic("mock out the GetNvLinkErrorCounter method")
|
|
// },
|
|
// GetNvLinkRemoteDeviceTypeFunc: func(n int) (nvml.IntNvLinkDeviceType, nvml.Return) {
|
|
// panic("mock out the GetNvLinkRemoteDeviceType method")
|
|
// },
|
|
// GetNvLinkRemotePciInfoFunc: func(n int) (nvml.PciInfo, nvml.Return) {
|
|
// panic("mock out the GetNvLinkRemotePciInfo method")
|
|
// },
|
|
// GetNvLinkStateFunc: func(n int) (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the GetNvLinkState method")
|
|
// },
|
|
// GetNvLinkUtilizationControlFunc: func(n1 int, n2 int) (nvml.NvLinkUtilizationControl, nvml.Return) {
|
|
// panic("mock out the GetNvLinkUtilizationControl method")
|
|
// },
|
|
// GetNvLinkUtilizationCounterFunc: func(n1 int, n2 int) (uint64, uint64, nvml.Return) {
|
|
// panic("mock out the GetNvLinkUtilizationCounter method")
|
|
// },
|
|
// GetNvLinkVersionFunc: func(n int) (uint32, nvml.Return) {
|
|
// panic("mock out the GetNvLinkVersion method")
|
|
// },
|
|
// GetP2PStatusFunc: func(device nvml.Device, gpuP2PCapsIndex nvml.GpuP2PCapsIndex) (nvml.GpuP2PStatus, nvml.Return) {
|
|
// panic("mock out the GetP2PStatus method")
|
|
// },
|
|
// GetPciInfoFunc: func() (nvml.PciInfo, nvml.Return) {
|
|
// panic("mock out the GetPciInfo method")
|
|
// },
|
|
// GetPcieLinkMaxSpeedFunc: func() (uint32, nvml.Return) {
|
|
// panic("mock out the GetPcieLinkMaxSpeed method")
|
|
// },
|
|
// GetPcieReplayCounterFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetPcieReplayCounter method")
|
|
// },
|
|
// GetPcieSpeedFunc: func() (int, nvml.Return) {
|
|
// panic("mock out the GetPcieSpeed method")
|
|
// },
|
|
// GetPcieThroughputFunc: func(pcieUtilCounter nvml.PcieUtilCounter) (uint32, nvml.Return) {
|
|
// panic("mock out the GetPcieThroughput method")
|
|
// },
|
|
// GetPerformanceStateFunc: func() (nvml.Pstates, nvml.Return) {
|
|
// panic("mock out the GetPerformanceState method")
|
|
// },
|
|
// GetPersistenceModeFunc: func() (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the GetPersistenceMode method")
|
|
// },
|
|
// GetPgpuMetadataStringFunc: func() (string, nvml.Return) {
|
|
// panic("mock out the GetPgpuMetadataString method")
|
|
// },
|
|
// GetPowerManagementDefaultLimitFunc: func() (uint32, nvml.Return) {
|
|
// panic("mock out the GetPowerManagementDefaultLimit method")
|
|
// },
|
|
// GetPowerManagementLimitFunc: func() (uint32, nvml.Return) {
|
|
// panic("mock out the GetPowerManagementLimit method")
|
|
// },
|
|
// GetPowerManagementLimitConstraintsFunc: func() (uint32, uint32, nvml.Return) {
|
|
// panic("mock out the GetPowerManagementLimitConstraints method")
|
|
// },
|
|
// GetPowerManagementModeFunc: func() (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the GetPowerManagementMode method")
|
|
// },
|
|
// GetPowerSourceFunc: func() (nvml.PowerSource, nvml.Return) {
|
|
// panic("mock out the GetPowerSource method")
|
|
// },
|
|
// GetPowerStateFunc: func() (nvml.Pstates, nvml.Return) {
|
|
// panic("mock out the GetPowerState method")
|
|
// },
|
|
// GetPowerUsageFunc: func() (uint32, nvml.Return) {
|
|
// panic("mock out the GetPowerUsage method")
|
|
// },
|
|
// GetProcessUtilizationFunc: func(v uint64) ([]nvml.ProcessUtilizationSample, nvml.Return) {
|
|
// panic("mock out the GetProcessUtilization method")
|
|
// },
|
|
// GetRemappedRowsFunc: func() (int, int, bool, bool, nvml.Return) {
|
|
// panic("mock out the GetRemappedRows method")
|
|
// },
|
|
// GetRetiredPagesFunc: func(pageRetirementCause nvml.PageRetirementCause) ([]uint64, nvml.Return) {
|
|
// panic("mock out the GetRetiredPages method")
|
|
// },
|
|
// GetRetiredPagesPendingStatusFunc: func() (nvml.EnableState, nvml.Return) {
|
|
// panic("mock out the GetRetiredPagesPendingStatus method")
|
|
// },
|
|
// GetRetiredPages_v2Func: func(pageRetirementCause nvml.PageRetirementCause) ([]uint64, []uint64, nvml.Return) {
|
|
// panic("mock out the GetRetiredPages_v2 method")
|
|
// },
|
|
// GetRowRemapperHistogramFunc: func() (nvml.RowRemapperHistogramValues, nvml.Return) {
|
|
// panic("mock out the GetRowRemapperHistogram method")
|
|
// },
|
|
// GetSamplesFunc: func(samplingType nvml.SamplingType, v uint64) (nvml.ValueType, []nvml.Sample, nvml.Return) {
|
|
// panic("mock out the GetSamples method")
|
|
// },
|
|
// GetSerialFunc: func() (string, nvml.Return) {
|
|
// panic("mock out the GetSerial method")
|
|
// },
|
|
// GetSupportedClocksThrottleReasonsFunc: func() (uint64, nvml.Return) {
|
|
// panic("mock out the GetSupportedClocksThrottleReasons method")
|
|
// },
|
|
// GetSupportedEventTypesFunc: func() (uint64, nvml.Return) {
|
|
// panic("mock out the GetSupportedEventTypes method")
|
|
// },
|
|
// GetSupportedGraphicsClocksFunc: func(n int) (int, uint32, nvml.Return) {
|
|
// panic("mock out the GetSupportedGraphicsClocks method")
|
|
// },
|
|
// GetSupportedMemoryClocksFunc: func() (int, uint32, nvml.Return) {
|
|
// panic("mock out the GetSupportedMemoryClocks method")
|
|
// },
|
|
// GetSupportedPerformanceStatesFunc: func() ([]nvml.Pstates, nvml.Return) {
|
|
// panic("mock out the GetSupportedPerformanceStates method")
|
|
// },
|
|
// GetSupportedVgpusFunc: func() ([]nvml.VgpuTypeId, nvml.Return) {
|
|
// panic("mock out the GetSupportedVgpus method")
|
|
// },
|
|
// GetTargetFanSpeedFunc: func(n int) (int, nvml.Return) {
|
|
// panic("mock out the GetTargetFanSpeed method")
|
|
// },
|
|
// GetTemperatureFunc: func(temperatureSensors nvml.TemperatureSensors) (uint32, nvml.Return) {
|
|
// panic("mock out the GetTemperature method")
|
|
// },
|
|
// GetTemperatureThresholdFunc: func(temperatureThresholds nvml.TemperatureThresholds) (uint32, nvml.Return) {
|
|
// panic("mock out the GetTemperatureThreshold method")
|
|
// },
|
|
// GetThermalSettingsFunc: func(v uint32) (nvml.GpuThermalSettings, nvml.Return) {
|
|
// panic("mock out the GetThermalSettings method")
|
|
// },
|
|
// GetTopologyCommonAncestorFunc: func(device nvml.Device) (nvml.GpuTopologyLevel, nvml.Return) {
|
|
// panic("mock out the GetTopologyCommonAncestor method")
|
|
// },
|
|
// GetTopologyNearestGpusFunc: func(gpuTopologyLevel nvml.GpuTopologyLevel) ([]nvml.Device, nvml.Return) {
|
|
// panic("mock out the GetTopologyNearestGpus method")
|
|
// },
|
|
// GetTotalEccErrorsFunc: func(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (uint64, nvml.Return) {
|
|
// panic("mock out the GetTotalEccErrors method")
|
|
// },
|
|
// GetTotalEnergyConsumptionFunc: func() (uint64, nvml.Return) {
|
|
// panic("mock out the GetTotalEnergyConsumption method")
|
|
// },
|
|
// GetUUIDFunc: func() (string, nvml.Return) {
|
|
// panic("mock out the GetUUID method")
|
|
// },
|
|
// GetUtilizationRatesFunc: func() (nvml.Utilization, nvml.Return) {
|
|
// panic("mock out the GetUtilizationRates method")
|
|
// },
|
|
// GetVbiosVersionFunc: func() (string, nvml.Return) {
|
|
// panic("mock out the GetVbiosVersion method")
|
|
// },
|
|
// GetVgpuCapabilitiesFunc: func(deviceVgpuCapability nvml.DeviceVgpuCapability) (bool, nvml.Return) {
|
|
// panic("mock out the GetVgpuCapabilities method")
|
|
// },
|
|
// GetVgpuMetadataFunc: func() (nvml.VgpuPgpuMetadata, nvml.Return) {
|
|
// panic("mock out the GetVgpuMetadata method")
|
|
// },
|
|
// GetVgpuProcessUtilizationFunc: func(v uint64) ([]nvml.VgpuProcessUtilizationSample, nvml.Return) {
|
|
// panic("mock out the GetVgpuProcessUtilization method")
|
|
// },
|
|
// GetVgpuSchedulerCapabilitiesFunc: func() (nvml.VgpuSchedulerCapabilities, nvml.Return) {
|
|
// panic("mock out the GetVgpuSchedulerCapabilities method")
|
|
// },
|
|
// GetVgpuSchedulerLogFunc: func() (nvml.VgpuSchedulerLog, nvml.Return) {
|
|
// panic("mock out the GetVgpuSchedulerLog method")
|
|
// },
|
|
// GetVgpuSchedulerStateFunc: func() (nvml.VgpuSchedulerGetState, nvml.Return) {
|
|
// panic("mock out the GetVgpuSchedulerState method")
|
|
// },
|
|
// GetVgpuUtilizationFunc: func(v uint64) (nvml.ValueType, []nvml.VgpuInstanceUtilizationSample, nvml.Return) {
|
|
// panic("mock out the GetVgpuUtilization method")
|
|
// },
|
|
// GetViolationStatusFunc: func(perfPolicyType nvml.PerfPolicyType) (nvml.ViolationTime, nvml.Return) {
|
|
// panic("mock out the GetViolationStatus method")
|
|
// },
|
|
// GetVirtualizationModeFunc: func() (nvml.GpuVirtualizationMode, nvml.Return) {
|
|
// panic("mock out the GetVirtualizationMode method")
|
|
// },
|
|
// GpmMigSampleGetFunc: func(n int, gpmSample nvml.GpmSample) nvml.Return {
|
|
// panic("mock out the GpmMigSampleGet method")
|
|
// },
|
|
// GpmQueryDeviceSupportFunc: func() (nvml.GpmSupport, nvml.Return) {
|
|
// panic("mock out the GpmQueryDeviceSupport method")
|
|
// },
|
|
// GpmQueryDeviceSupportVFunc: func() nvml.GpmSupportV {
|
|
// panic("mock out the GpmQueryDeviceSupportV method")
|
|
// },
|
|
// GpmSampleGetFunc: func(gpmSample nvml.GpmSample) nvml.Return {
|
|
// panic("mock out the GpmSampleGet method")
|
|
// },
|
|
// IsMigDeviceHandleFunc: func() (bool, nvml.Return) {
|
|
// panic("mock out the IsMigDeviceHandle method")
|
|
// },
|
|
// OnSameBoardFunc: func(device nvml.Device) (int, nvml.Return) {
|
|
// panic("mock out the OnSameBoard method")
|
|
// },
|
|
// RegisterEventsFunc: func(v uint64, eventSet nvml.EventSet) nvml.Return {
|
|
// panic("mock out the RegisterEvents method")
|
|
// },
|
|
// ResetApplicationsClocksFunc: func() nvml.Return {
|
|
// panic("mock out the ResetApplicationsClocks method")
|
|
// },
|
|
// ResetGpuLockedClocksFunc: func() nvml.Return {
|
|
// panic("mock out the ResetGpuLockedClocks method")
|
|
// },
|
|
// ResetMemoryLockedClocksFunc: func() nvml.Return {
|
|
// panic("mock out the ResetMemoryLockedClocks method")
|
|
// },
|
|
// ResetNvLinkErrorCountersFunc: func(n int) nvml.Return {
|
|
// panic("mock out the ResetNvLinkErrorCounters method")
|
|
// },
|
|
// ResetNvLinkUtilizationCounterFunc: func(n1 int, n2 int) nvml.Return {
|
|
// panic("mock out the ResetNvLinkUtilizationCounter method")
|
|
// },
|
|
// SetAPIRestrictionFunc: func(restrictedAPI nvml.RestrictedAPI, enableState nvml.EnableState) nvml.Return {
|
|
// panic("mock out the SetAPIRestriction method")
|
|
// },
|
|
// SetAccountingModeFunc: func(enableState nvml.EnableState) nvml.Return {
|
|
// panic("mock out the SetAccountingMode method")
|
|
// },
|
|
// SetApplicationsClocksFunc: func(v1 uint32, v2 uint32) nvml.Return {
|
|
// panic("mock out the SetApplicationsClocks method")
|
|
// },
|
|
// SetAutoBoostedClocksEnabledFunc: func(enableState nvml.EnableState) nvml.Return {
|
|
// panic("mock out the SetAutoBoostedClocksEnabled method")
|
|
// },
|
|
// SetComputeModeFunc: func(computeMode nvml.ComputeMode) nvml.Return {
|
|
// panic("mock out the SetComputeMode method")
|
|
// },
|
|
// SetCpuAffinityFunc: func() nvml.Return {
|
|
// panic("mock out the SetCpuAffinity method")
|
|
// },
|
|
// SetDefaultAutoBoostedClocksEnabledFunc: func(enableState nvml.EnableState, v uint32) nvml.Return {
|
|
// panic("mock out the SetDefaultAutoBoostedClocksEnabled method")
|
|
// },
|
|
// SetDefaultFanSpeed_v2Func: func(n int) nvml.Return {
|
|
// panic("mock out the SetDefaultFanSpeed_v2 method")
|
|
// },
|
|
// SetDriverModelFunc: func(driverModel nvml.DriverModel, v uint32) nvml.Return {
|
|
// panic("mock out the SetDriverModel method")
|
|
// },
|
|
// SetEccModeFunc: func(enableState nvml.EnableState) nvml.Return {
|
|
// panic("mock out the SetEccMode method")
|
|
// },
|
|
// SetFanControlPolicyFunc: func(n int, fanControlPolicy nvml.FanControlPolicy) nvml.Return {
|
|
// panic("mock out the SetFanControlPolicy method")
|
|
// },
|
|
// SetFanSpeed_v2Func: func(n1 int, n2 int) nvml.Return {
|
|
// panic("mock out the SetFanSpeed_v2 method")
|
|
// },
|
|
// SetGpcClkVfOffsetFunc: func(n int) nvml.Return {
|
|
// panic("mock out the SetGpcClkVfOffset method")
|
|
// },
|
|
// SetGpuLockedClocksFunc: func(v1 uint32, v2 uint32) nvml.Return {
|
|
// panic("mock out the SetGpuLockedClocks method")
|
|
// },
|
|
// SetGpuOperationModeFunc: func(gpuOperationMode nvml.GpuOperationMode) nvml.Return {
|
|
// panic("mock out the SetGpuOperationMode method")
|
|
// },
|
|
// SetMemClkVfOffsetFunc: func(n int) nvml.Return {
|
|
// panic("mock out the SetMemClkVfOffset method")
|
|
// },
|
|
// SetMemoryLockedClocksFunc: func(v1 uint32, v2 uint32) nvml.Return {
|
|
// panic("mock out the SetMemoryLockedClocks method")
|
|
// },
|
|
// SetMigModeFunc: func(n int) (nvml.Return, nvml.Return) {
|
|
// panic("mock out the SetMigMode method")
|
|
// },
|
|
// SetNvLinkDeviceLowPowerThresholdFunc: func(nvLinkPowerThres *nvml.NvLinkPowerThres) nvml.Return {
|
|
// panic("mock out the SetNvLinkDeviceLowPowerThreshold method")
|
|
// },
|
|
// SetNvLinkUtilizationControlFunc: func(n1 int, n2 int, nvLinkUtilizationControl *nvml.NvLinkUtilizationControl, b bool) nvml.Return {
|
|
// panic("mock out the SetNvLinkUtilizationControl method")
|
|
// },
|
|
// SetPersistenceModeFunc: func(enableState nvml.EnableState) nvml.Return {
|
|
// panic("mock out the SetPersistenceMode method")
|
|
// },
|
|
// SetPowerManagementLimitFunc: func(v uint32) nvml.Return {
|
|
// panic("mock out the SetPowerManagementLimit method")
|
|
// },
|
|
// SetTemperatureThresholdFunc: func(temperatureThresholds nvml.TemperatureThresholds, n int) nvml.Return {
|
|
// panic("mock out the SetTemperatureThreshold method")
|
|
// },
|
|
// SetVgpuSchedulerStateFunc: func(vgpuSchedulerSetState *nvml.VgpuSchedulerSetState) nvml.Return {
|
|
// panic("mock out the SetVgpuSchedulerState method")
|
|
// },
|
|
// SetVirtualizationModeFunc: func(gpuVirtualizationMode nvml.GpuVirtualizationMode) nvml.Return {
|
|
// panic("mock out the SetVirtualizationMode method")
|
|
// },
|
|
// ValidateInforomFunc: func() nvml.Return {
|
|
// panic("mock out the ValidateInforom method")
|
|
// },
|
|
// VgpuTypeGetMaxInstancesFunc: func(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
|
|
// panic("mock out the VgpuTypeGetMaxInstances method")
|
|
// },
|
|
// }
|
|
//
|
|
// // use mockedDevice in code that requires nvml.Device
|
|
// // and then make assertions.
|
|
//
|
|
// }
|
|
type Device struct {
|
|
// CcuGetStreamStateFunc mocks the CcuGetStreamState method.
|
|
CcuGetStreamStateFunc func() (int, nvml.Return)
|
|
|
|
// CcuSetStreamStateFunc mocks the CcuSetStreamState method.
|
|
CcuSetStreamStateFunc func(n int) nvml.Return
|
|
|
|
// ClearAccountingPidsFunc mocks the ClearAccountingPids method.
|
|
ClearAccountingPidsFunc func() nvml.Return
|
|
|
|
// ClearCpuAffinityFunc mocks the ClearCpuAffinity method.
|
|
ClearCpuAffinityFunc func() nvml.Return
|
|
|
|
// ClearEccErrorCountsFunc mocks the ClearEccErrorCounts method.
|
|
ClearEccErrorCountsFunc func(eccCounterType nvml.EccCounterType) nvml.Return
|
|
|
|
// ClearFieldValuesFunc mocks the ClearFieldValues method.
|
|
ClearFieldValuesFunc func(fieldValues []nvml.FieldValue) nvml.Return
|
|
|
|
// CreateGpuInstanceFunc mocks the CreateGpuInstance method.
|
|
CreateGpuInstanceFunc func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (nvml.GpuInstance, nvml.Return)
|
|
|
|
// CreateGpuInstanceWithPlacementFunc mocks the CreateGpuInstanceWithPlacement method.
|
|
CreateGpuInstanceWithPlacementFunc func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo, gpuInstancePlacement *nvml.GpuInstancePlacement) (nvml.GpuInstance, nvml.Return)
|
|
|
|
// FreezeNvLinkUtilizationCounterFunc mocks the FreezeNvLinkUtilizationCounter method.
|
|
FreezeNvLinkUtilizationCounterFunc func(n1 int, n2 int, enableState nvml.EnableState) nvml.Return
|
|
|
|
// GetAPIRestrictionFunc mocks the GetAPIRestriction method.
|
|
GetAPIRestrictionFunc func(restrictedAPI nvml.RestrictedAPI) (nvml.EnableState, nvml.Return)
|
|
|
|
// GetAccountingBufferSizeFunc mocks the GetAccountingBufferSize method.
|
|
GetAccountingBufferSizeFunc func() (int, nvml.Return)
|
|
|
|
// GetAccountingModeFunc mocks the GetAccountingMode method.
|
|
GetAccountingModeFunc func() (nvml.EnableState, nvml.Return)
|
|
|
|
// GetAccountingPidsFunc mocks the GetAccountingPids method.
|
|
GetAccountingPidsFunc func() ([]int, nvml.Return)
|
|
|
|
// GetAccountingStatsFunc mocks the GetAccountingStats method.
|
|
GetAccountingStatsFunc func(v uint32) (nvml.AccountingStats, nvml.Return)
|
|
|
|
// GetActiveVgpusFunc mocks the GetActiveVgpus method.
|
|
GetActiveVgpusFunc func() ([]nvml.VgpuInstance, nvml.Return)
|
|
|
|
// GetAdaptiveClockInfoStatusFunc mocks the GetAdaptiveClockInfoStatus method.
|
|
GetAdaptiveClockInfoStatusFunc func() (uint32, nvml.Return)
|
|
|
|
// GetApplicationsClockFunc mocks the GetApplicationsClock method.
|
|
GetApplicationsClockFunc func(clockType nvml.ClockType) (uint32, nvml.Return)
|
|
|
|
// GetArchitectureFunc mocks the GetArchitecture method.
|
|
GetArchitectureFunc func() (nvml.DeviceArchitecture, nvml.Return)
|
|
|
|
// GetAttributesFunc mocks the GetAttributes method.
|
|
GetAttributesFunc func() (nvml.DeviceAttributes, nvml.Return)
|
|
|
|
// GetAutoBoostedClocksEnabledFunc mocks the GetAutoBoostedClocksEnabled method.
|
|
GetAutoBoostedClocksEnabledFunc func() (nvml.EnableState, nvml.EnableState, nvml.Return)
|
|
|
|
// GetBAR1MemoryInfoFunc mocks the GetBAR1MemoryInfo method.
|
|
GetBAR1MemoryInfoFunc func() (nvml.BAR1Memory, nvml.Return)
|
|
|
|
// GetBoardIdFunc mocks the GetBoardId method.
|
|
GetBoardIdFunc func() (uint32, nvml.Return)
|
|
|
|
// GetBoardPartNumberFunc mocks the GetBoardPartNumber method.
|
|
GetBoardPartNumberFunc func() (string, nvml.Return)
|
|
|
|
// GetBrandFunc mocks the GetBrand method.
|
|
GetBrandFunc func() (nvml.BrandType, nvml.Return)
|
|
|
|
// GetBridgeChipInfoFunc mocks the GetBridgeChipInfo method.
|
|
GetBridgeChipInfoFunc func() (nvml.BridgeChipHierarchy, nvml.Return)
|
|
|
|
// GetBusTypeFunc mocks the GetBusType method.
|
|
GetBusTypeFunc func() (nvml.BusType, nvml.Return)
|
|
|
|
// GetClkMonStatusFunc mocks the GetClkMonStatus method.
|
|
GetClkMonStatusFunc func() (nvml.ClkMonStatus, nvml.Return)
|
|
|
|
// GetClockFunc mocks the GetClock method.
|
|
GetClockFunc func(clockType nvml.ClockType, clockId nvml.ClockId) (uint32, nvml.Return)
|
|
|
|
// GetClockInfoFunc mocks the GetClockInfo method.
|
|
GetClockInfoFunc func(clockType nvml.ClockType) (uint32, nvml.Return)
|
|
|
|
// GetComputeInstanceIdFunc mocks the GetComputeInstanceId method.
|
|
GetComputeInstanceIdFunc func() (int, nvml.Return)
|
|
|
|
// GetComputeModeFunc mocks the GetComputeMode method.
|
|
GetComputeModeFunc func() (nvml.ComputeMode, nvml.Return)
|
|
|
|
// GetComputeRunningProcessesFunc mocks the GetComputeRunningProcesses method.
|
|
GetComputeRunningProcessesFunc func() ([]nvml.ProcessInfo, nvml.Return)
|
|
|
|
// GetCpuAffinityFunc mocks the GetCpuAffinity method.
|
|
GetCpuAffinityFunc func(n int) ([]uint, nvml.Return)
|
|
|
|
// GetCpuAffinityWithinScopeFunc mocks the GetCpuAffinityWithinScope method.
|
|
GetCpuAffinityWithinScopeFunc func(n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return)
|
|
|
|
// GetCreatableVgpusFunc mocks the GetCreatableVgpus method.
|
|
GetCreatableVgpusFunc func() ([]nvml.VgpuTypeId, nvml.Return)
|
|
|
|
// GetCudaComputeCapabilityFunc mocks the GetCudaComputeCapability method.
|
|
GetCudaComputeCapabilityFunc func() (int, int, nvml.Return)
|
|
|
|
// GetCurrPcieLinkGenerationFunc mocks the GetCurrPcieLinkGeneration method.
|
|
GetCurrPcieLinkGenerationFunc func() (int, nvml.Return)
|
|
|
|
// GetCurrPcieLinkWidthFunc mocks the GetCurrPcieLinkWidth method.
|
|
GetCurrPcieLinkWidthFunc func() (int, nvml.Return)
|
|
|
|
// GetCurrentClocksThrottleReasonsFunc mocks the GetCurrentClocksThrottleReasons method.
|
|
GetCurrentClocksThrottleReasonsFunc func() (uint64, nvml.Return)
|
|
|
|
// GetDecoderUtilizationFunc mocks the GetDecoderUtilization method.
|
|
GetDecoderUtilizationFunc func() (uint32, uint32, nvml.Return)
|
|
|
|
// GetDefaultApplicationsClockFunc mocks the GetDefaultApplicationsClock method.
|
|
GetDefaultApplicationsClockFunc func(clockType nvml.ClockType) (uint32, nvml.Return)
|
|
|
|
// GetDefaultEccModeFunc mocks the GetDefaultEccMode method.
|
|
GetDefaultEccModeFunc func() (nvml.EnableState, nvml.Return)
|
|
|
|
// GetDetailedEccErrorsFunc mocks the GetDetailedEccErrors method.
|
|
GetDetailedEccErrorsFunc func(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (nvml.EccErrorCounts, nvml.Return)
|
|
|
|
// GetDeviceHandleFromMigDeviceHandleFunc mocks the GetDeviceHandleFromMigDeviceHandle method.
|
|
GetDeviceHandleFromMigDeviceHandleFunc func() (nvml.Device, nvml.Return)
|
|
|
|
// GetDisplayActiveFunc mocks the GetDisplayActive method.
|
|
GetDisplayActiveFunc func() (nvml.EnableState, nvml.Return)
|
|
|
|
// GetDisplayModeFunc mocks the GetDisplayMode method.
|
|
GetDisplayModeFunc func() (nvml.EnableState, nvml.Return)
|
|
|
|
// GetDriverModelFunc mocks the GetDriverModel method.
|
|
GetDriverModelFunc func() (nvml.DriverModel, nvml.DriverModel, nvml.Return)
|
|
|
|
// GetDynamicPstatesInfoFunc mocks the GetDynamicPstatesInfo method.
|
|
GetDynamicPstatesInfoFunc func() (nvml.GpuDynamicPstatesInfo, nvml.Return)
|
|
|
|
// GetEccModeFunc mocks the GetEccMode method.
|
|
GetEccModeFunc func() (nvml.EnableState, nvml.EnableState, nvml.Return)
|
|
|
|
// GetEncoderCapacityFunc mocks the GetEncoderCapacity method.
|
|
GetEncoderCapacityFunc func(encoderType nvml.EncoderType) (int, nvml.Return)
|
|
|
|
// GetEncoderSessionsFunc mocks the GetEncoderSessions method.
|
|
GetEncoderSessionsFunc func() ([]nvml.EncoderSessionInfo, nvml.Return)
|
|
|
|
// GetEncoderStatsFunc mocks the GetEncoderStats method.
|
|
GetEncoderStatsFunc func() (int, uint32, uint32, nvml.Return)
|
|
|
|
// GetEncoderUtilizationFunc mocks the GetEncoderUtilization method.
|
|
GetEncoderUtilizationFunc func() (uint32, uint32, nvml.Return)
|
|
|
|
// GetEnforcedPowerLimitFunc mocks the GetEnforcedPowerLimit method.
|
|
GetEnforcedPowerLimitFunc func() (uint32, nvml.Return)
|
|
|
|
// GetFBCSessionsFunc mocks the GetFBCSessions method.
|
|
GetFBCSessionsFunc func() ([]nvml.FBCSessionInfo, nvml.Return)
|
|
|
|
// GetFBCStatsFunc mocks the GetFBCStats method.
|
|
GetFBCStatsFunc func() (nvml.FBCStats, nvml.Return)
|
|
|
|
// GetFanControlPolicy_v2Func mocks the GetFanControlPolicy_v2 method.
|
|
GetFanControlPolicy_v2Func func(n int) (nvml.FanControlPolicy, nvml.Return)
|
|
|
|
// GetFanSpeedFunc mocks the GetFanSpeed method.
|
|
GetFanSpeedFunc func() (uint32, nvml.Return)
|
|
|
|
// GetFanSpeed_v2Func mocks the GetFanSpeed_v2 method.
|
|
GetFanSpeed_v2Func func(n int) (uint32, nvml.Return)
|
|
|
|
// GetFieldValuesFunc mocks the GetFieldValues method.
|
|
GetFieldValuesFunc func(fieldValues []nvml.FieldValue) nvml.Return
|
|
|
|
// GetGpcClkMinMaxVfOffsetFunc mocks the GetGpcClkMinMaxVfOffset method.
|
|
GetGpcClkMinMaxVfOffsetFunc func() (int, int, nvml.Return)
|
|
|
|
// GetGpcClkVfOffsetFunc mocks the GetGpcClkVfOffset method.
|
|
GetGpcClkVfOffsetFunc func() (int, nvml.Return)
|
|
|
|
// GetGpuFabricInfoFunc mocks the GetGpuFabricInfo method.
|
|
GetGpuFabricInfoFunc func() (nvml.GpuFabricInfo, nvml.Return)
|
|
|
|
// GetGpuInstanceByIdFunc mocks the GetGpuInstanceById method.
|
|
GetGpuInstanceByIdFunc func(n int) (nvml.GpuInstance, nvml.Return)
|
|
|
|
// GetGpuInstanceIdFunc mocks the GetGpuInstanceId method.
|
|
GetGpuInstanceIdFunc func() (int, nvml.Return)
|
|
|
|
// GetGpuInstancePossiblePlacementsFunc mocks the GetGpuInstancePossiblePlacements method.
|
|
GetGpuInstancePossiblePlacementsFunc func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstancePlacement, nvml.Return)
|
|
|
|
// GetGpuInstanceProfileInfoFunc mocks the GetGpuInstanceProfileInfo method.
|
|
GetGpuInstanceProfileInfoFunc func(n int) (nvml.GpuInstanceProfileInfo, nvml.Return)
|
|
|
|
// GetGpuInstanceProfileInfoVFunc mocks the GetGpuInstanceProfileInfoV method.
|
|
GetGpuInstanceProfileInfoVFunc func(n int) nvml.GpuInstanceProfileInfoV
|
|
|
|
// GetGpuInstanceRemainingCapacityFunc mocks the GetGpuInstanceRemainingCapacity method.
|
|
GetGpuInstanceRemainingCapacityFunc func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (int, nvml.Return)
|
|
|
|
// GetGpuInstancesFunc mocks the GetGpuInstances method.
|
|
GetGpuInstancesFunc func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstance, nvml.Return)
|
|
|
|
// GetGpuMaxPcieLinkGenerationFunc mocks the GetGpuMaxPcieLinkGeneration method.
|
|
GetGpuMaxPcieLinkGenerationFunc func() (int, nvml.Return)
|
|
|
|
// GetGpuOperationModeFunc mocks the GetGpuOperationMode method.
|
|
GetGpuOperationModeFunc func() (nvml.GpuOperationMode, nvml.GpuOperationMode, nvml.Return)
|
|
|
|
// GetGraphicsRunningProcessesFunc mocks the GetGraphicsRunningProcesses method.
|
|
GetGraphicsRunningProcessesFunc func() ([]nvml.ProcessInfo, nvml.Return)
|
|
|
|
// GetGridLicensableFeaturesFunc mocks the GetGridLicensableFeatures method.
|
|
GetGridLicensableFeaturesFunc func() (nvml.GridLicensableFeatures, nvml.Return)
|
|
|
|
// GetGspFirmwareModeFunc mocks the GetGspFirmwareMode method.
|
|
GetGspFirmwareModeFunc func() (bool, bool, nvml.Return)
|
|
|
|
// GetGspFirmwareVersionFunc mocks the GetGspFirmwareVersion method.
|
|
GetGspFirmwareVersionFunc func() (string, nvml.Return)
|
|
|
|
// GetHostVgpuModeFunc mocks the GetHostVgpuMode method.
|
|
GetHostVgpuModeFunc func() (nvml.HostVgpuMode, nvml.Return)
|
|
|
|
// GetIndexFunc mocks the GetIndex method.
|
|
GetIndexFunc func() (int, nvml.Return)
|
|
|
|
// GetInforomConfigurationChecksumFunc mocks the GetInforomConfigurationChecksum method.
|
|
GetInforomConfigurationChecksumFunc func() (uint32, nvml.Return)
|
|
|
|
// GetInforomImageVersionFunc mocks the GetInforomImageVersion method.
|
|
GetInforomImageVersionFunc func() (string, nvml.Return)
|
|
|
|
// GetInforomVersionFunc mocks the GetInforomVersion method.
|
|
GetInforomVersionFunc func(inforomObject nvml.InforomObject) (string, nvml.Return)
|
|
|
|
// GetIrqNumFunc mocks the GetIrqNum method.
|
|
GetIrqNumFunc func() (int, nvml.Return)
|
|
|
|
// GetMPSComputeRunningProcessesFunc mocks the GetMPSComputeRunningProcesses method.
|
|
GetMPSComputeRunningProcessesFunc func() ([]nvml.ProcessInfo, nvml.Return)
|
|
|
|
// GetMaxClockInfoFunc mocks the GetMaxClockInfo method.
|
|
GetMaxClockInfoFunc func(clockType nvml.ClockType) (uint32, nvml.Return)
|
|
|
|
// GetMaxCustomerBoostClockFunc mocks the GetMaxCustomerBoostClock method.
|
|
GetMaxCustomerBoostClockFunc func(clockType nvml.ClockType) (uint32, nvml.Return)
|
|
|
|
// GetMaxMigDeviceCountFunc mocks the GetMaxMigDeviceCount method.
|
|
GetMaxMigDeviceCountFunc func() (int, nvml.Return)
|
|
|
|
// GetMaxPcieLinkGenerationFunc mocks the GetMaxPcieLinkGeneration method.
|
|
GetMaxPcieLinkGenerationFunc func() (int, nvml.Return)
|
|
|
|
// GetMaxPcieLinkWidthFunc mocks the GetMaxPcieLinkWidth method.
|
|
GetMaxPcieLinkWidthFunc func() (int, nvml.Return)
|
|
|
|
// GetMemClkMinMaxVfOffsetFunc mocks the GetMemClkMinMaxVfOffset method.
|
|
GetMemClkMinMaxVfOffsetFunc func() (int, int, nvml.Return)
|
|
|
|
// GetMemClkVfOffsetFunc mocks the GetMemClkVfOffset method.
|
|
GetMemClkVfOffsetFunc func() (int, nvml.Return)
|
|
|
|
// GetMemoryAffinityFunc mocks the GetMemoryAffinity method.
|
|
GetMemoryAffinityFunc func(n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return)
|
|
|
|
// GetMemoryBusWidthFunc mocks the GetMemoryBusWidth method.
|
|
GetMemoryBusWidthFunc func() (uint32, nvml.Return)
|
|
|
|
// GetMemoryErrorCounterFunc mocks the GetMemoryErrorCounter method.
|
|
GetMemoryErrorCounterFunc func(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType, memoryLocation nvml.MemoryLocation) (uint64, nvml.Return)
|
|
|
|
// GetMemoryInfoFunc mocks the GetMemoryInfo method.
|
|
GetMemoryInfoFunc func() (nvml.Memory, nvml.Return)
|
|
|
|
// GetMemoryInfo_v2Func mocks the GetMemoryInfo_v2 method.
|
|
GetMemoryInfo_v2Func func() (nvml.Memory_v2, nvml.Return)
|
|
|
|
// GetMigDeviceHandleByIndexFunc mocks the GetMigDeviceHandleByIndex method.
|
|
GetMigDeviceHandleByIndexFunc func(n int) (nvml.Device, nvml.Return)
|
|
|
|
// GetMigModeFunc mocks the GetMigMode method.
|
|
GetMigModeFunc func() (int, int, nvml.Return)
|
|
|
|
// GetMinMaxClockOfPStateFunc mocks the GetMinMaxClockOfPState method.
|
|
GetMinMaxClockOfPStateFunc func(clockType nvml.ClockType, pstates nvml.Pstates) (uint32, uint32, nvml.Return)
|
|
|
|
// GetMinMaxFanSpeedFunc mocks the GetMinMaxFanSpeed method.
|
|
GetMinMaxFanSpeedFunc func() (int, int, nvml.Return)
|
|
|
|
// GetMinorNumberFunc mocks the GetMinorNumber method.
|
|
GetMinorNumberFunc func() (int, nvml.Return)
|
|
|
|
// GetMultiGpuBoardFunc mocks the GetMultiGpuBoard method.
|
|
GetMultiGpuBoardFunc func() (int, nvml.Return)
|
|
|
|
// GetNameFunc mocks the GetName method.
|
|
GetNameFunc func() (string, nvml.Return)
|
|
|
|
// GetNumFansFunc mocks the GetNumFans method.
|
|
GetNumFansFunc func() (int, nvml.Return)
|
|
|
|
// GetNumGpuCoresFunc mocks the GetNumGpuCores method.
|
|
GetNumGpuCoresFunc func() (int, nvml.Return)
|
|
|
|
// GetNvLinkCapabilityFunc mocks the GetNvLinkCapability method.
|
|
GetNvLinkCapabilityFunc func(n int, nvLinkCapability nvml.NvLinkCapability) (uint32, nvml.Return)
|
|
|
|
// GetNvLinkErrorCounterFunc mocks the GetNvLinkErrorCounter method.
|
|
GetNvLinkErrorCounterFunc func(n int, nvLinkErrorCounter nvml.NvLinkErrorCounter) (uint64, nvml.Return)
|
|
|
|
// GetNvLinkRemoteDeviceTypeFunc mocks the GetNvLinkRemoteDeviceType method.
|
|
GetNvLinkRemoteDeviceTypeFunc func(n int) (nvml.IntNvLinkDeviceType, nvml.Return)
|
|
|
|
// GetNvLinkRemotePciInfoFunc mocks the GetNvLinkRemotePciInfo method.
|
|
GetNvLinkRemotePciInfoFunc func(n int) (nvml.PciInfo, nvml.Return)
|
|
|
|
// GetNvLinkStateFunc mocks the GetNvLinkState method.
|
|
GetNvLinkStateFunc func(n int) (nvml.EnableState, nvml.Return)
|
|
|
|
// GetNvLinkUtilizationControlFunc mocks the GetNvLinkUtilizationControl method.
|
|
GetNvLinkUtilizationControlFunc func(n1 int, n2 int) (nvml.NvLinkUtilizationControl, nvml.Return)
|
|
|
|
// GetNvLinkUtilizationCounterFunc mocks the GetNvLinkUtilizationCounter method.
|
|
GetNvLinkUtilizationCounterFunc func(n1 int, n2 int) (uint64, uint64, nvml.Return)
|
|
|
|
// GetNvLinkVersionFunc mocks the GetNvLinkVersion method.
|
|
GetNvLinkVersionFunc func(n int) (uint32, nvml.Return)
|
|
|
|
// GetP2PStatusFunc mocks the GetP2PStatus method.
|
|
GetP2PStatusFunc func(device nvml.Device, gpuP2PCapsIndex nvml.GpuP2PCapsIndex) (nvml.GpuP2PStatus, nvml.Return)
|
|
|
|
// GetPciInfoFunc mocks the GetPciInfo method.
|
|
GetPciInfoFunc func() (nvml.PciInfo, nvml.Return)
|
|
|
|
// GetPcieLinkMaxSpeedFunc mocks the GetPcieLinkMaxSpeed method.
|
|
GetPcieLinkMaxSpeedFunc func() (uint32, nvml.Return)
|
|
|
|
// GetPcieReplayCounterFunc mocks the GetPcieReplayCounter method.
|
|
GetPcieReplayCounterFunc func() (int, nvml.Return)
|
|
|
|
// GetPcieSpeedFunc mocks the GetPcieSpeed method.
|
|
GetPcieSpeedFunc func() (int, nvml.Return)
|
|
|
|
// GetPcieThroughputFunc mocks the GetPcieThroughput method.
|
|
GetPcieThroughputFunc func(pcieUtilCounter nvml.PcieUtilCounter) (uint32, nvml.Return)
|
|
|
|
// GetPerformanceStateFunc mocks the GetPerformanceState method.
|
|
GetPerformanceStateFunc func() (nvml.Pstates, nvml.Return)
|
|
|
|
// GetPersistenceModeFunc mocks the GetPersistenceMode method.
|
|
GetPersistenceModeFunc func() (nvml.EnableState, nvml.Return)
|
|
|
|
// GetPgpuMetadataStringFunc mocks the GetPgpuMetadataString method.
|
|
GetPgpuMetadataStringFunc func() (string, nvml.Return)
|
|
|
|
// GetPowerManagementDefaultLimitFunc mocks the GetPowerManagementDefaultLimit method.
|
|
GetPowerManagementDefaultLimitFunc func() (uint32, nvml.Return)
|
|
|
|
// GetPowerManagementLimitFunc mocks the GetPowerManagementLimit method.
|
|
GetPowerManagementLimitFunc func() (uint32, nvml.Return)
|
|
|
|
// GetPowerManagementLimitConstraintsFunc mocks the GetPowerManagementLimitConstraints method.
|
|
GetPowerManagementLimitConstraintsFunc func() (uint32, uint32, nvml.Return)
|
|
|
|
// GetPowerManagementModeFunc mocks the GetPowerManagementMode method.
|
|
GetPowerManagementModeFunc func() (nvml.EnableState, nvml.Return)
|
|
|
|
// GetPowerSourceFunc mocks the GetPowerSource method.
|
|
GetPowerSourceFunc func() (nvml.PowerSource, nvml.Return)
|
|
|
|
// GetPowerStateFunc mocks the GetPowerState method.
|
|
GetPowerStateFunc func() (nvml.Pstates, nvml.Return)
|
|
|
|
// GetPowerUsageFunc mocks the GetPowerUsage method.
|
|
GetPowerUsageFunc func() (uint32, nvml.Return)
|
|
|
|
// GetProcessUtilizationFunc mocks the GetProcessUtilization method.
|
|
GetProcessUtilizationFunc func(v uint64) ([]nvml.ProcessUtilizationSample, nvml.Return)
|
|
|
|
// GetRemappedRowsFunc mocks the GetRemappedRows method.
|
|
GetRemappedRowsFunc func() (int, int, bool, bool, nvml.Return)
|
|
|
|
// GetRetiredPagesFunc mocks the GetRetiredPages method.
|
|
GetRetiredPagesFunc func(pageRetirementCause nvml.PageRetirementCause) ([]uint64, nvml.Return)
|
|
|
|
// GetRetiredPagesPendingStatusFunc mocks the GetRetiredPagesPendingStatus method.
|
|
GetRetiredPagesPendingStatusFunc func() (nvml.EnableState, nvml.Return)
|
|
|
|
// GetRetiredPages_v2Func mocks the GetRetiredPages_v2 method.
|
|
GetRetiredPages_v2Func func(pageRetirementCause nvml.PageRetirementCause) ([]uint64, []uint64, nvml.Return)
|
|
|
|
// GetRowRemapperHistogramFunc mocks the GetRowRemapperHistogram method.
|
|
GetRowRemapperHistogramFunc func() (nvml.RowRemapperHistogramValues, nvml.Return)
|
|
|
|
// GetSamplesFunc mocks the GetSamples method.
|
|
GetSamplesFunc func(samplingType nvml.SamplingType, v uint64) (nvml.ValueType, []nvml.Sample, nvml.Return)
|
|
|
|
// GetSerialFunc mocks the GetSerial method.
|
|
GetSerialFunc func() (string, nvml.Return)
|
|
|
|
// GetSupportedClocksThrottleReasonsFunc mocks the GetSupportedClocksThrottleReasons method.
|
|
GetSupportedClocksThrottleReasonsFunc func() (uint64, nvml.Return)
|
|
|
|
// GetSupportedEventTypesFunc mocks the GetSupportedEventTypes method.
|
|
GetSupportedEventTypesFunc func() (uint64, nvml.Return)
|
|
|
|
// GetSupportedGraphicsClocksFunc mocks the GetSupportedGraphicsClocks method.
|
|
GetSupportedGraphicsClocksFunc func(n int) (int, uint32, nvml.Return)
|
|
|
|
// GetSupportedMemoryClocksFunc mocks the GetSupportedMemoryClocks method.
|
|
GetSupportedMemoryClocksFunc func() (int, uint32, nvml.Return)
|
|
|
|
// GetSupportedPerformanceStatesFunc mocks the GetSupportedPerformanceStates method.
|
|
GetSupportedPerformanceStatesFunc func() ([]nvml.Pstates, nvml.Return)
|
|
|
|
// GetSupportedVgpusFunc mocks the GetSupportedVgpus method.
|
|
GetSupportedVgpusFunc func() ([]nvml.VgpuTypeId, nvml.Return)
|
|
|
|
// GetTargetFanSpeedFunc mocks the GetTargetFanSpeed method.
|
|
GetTargetFanSpeedFunc func(n int) (int, nvml.Return)
|
|
|
|
// GetTemperatureFunc mocks the GetTemperature method.
|
|
GetTemperatureFunc func(temperatureSensors nvml.TemperatureSensors) (uint32, nvml.Return)
|
|
|
|
// GetTemperatureThresholdFunc mocks the GetTemperatureThreshold method.
|
|
GetTemperatureThresholdFunc func(temperatureThresholds nvml.TemperatureThresholds) (uint32, nvml.Return)
|
|
|
|
// GetThermalSettingsFunc mocks the GetThermalSettings method.
|
|
GetThermalSettingsFunc func(v uint32) (nvml.GpuThermalSettings, nvml.Return)
|
|
|
|
// GetTopologyCommonAncestorFunc mocks the GetTopologyCommonAncestor method.
|
|
GetTopologyCommonAncestorFunc func(device nvml.Device) (nvml.GpuTopologyLevel, nvml.Return)
|
|
|
|
// GetTopologyNearestGpusFunc mocks the GetTopologyNearestGpus method.
|
|
GetTopologyNearestGpusFunc func(gpuTopologyLevel nvml.GpuTopologyLevel) ([]nvml.Device, nvml.Return)
|
|
|
|
// GetTotalEccErrorsFunc mocks the GetTotalEccErrors method.
|
|
GetTotalEccErrorsFunc func(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (uint64, nvml.Return)
|
|
|
|
// GetTotalEnergyConsumptionFunc mocks the GetTotalEnergyConsumption method.
|
|
GetTotalEnergyConsumptionFunc func() (uint64, nvml.Return)
|
|
|
|
// GetUUIDFunc mocks the GetUUID method.
|
|
GetUUIDFunc func() (string, nvml.Return)
|
|
|
|
// GetUtilizationRatesFunc mocks the GetUtilizationRates method.
|
|
GetUtilizationRatesFunc func() (nvml.Utilization, nvml.Return)
|
|
|
|
// GetVbiosVersionFunc mocks the GetVbiosVersion method.
|
|
GetVbiosVersionFunc func() (string, nvml.Return)
|
|
|
|
// GetVgpuCapabilitiesFunc mocks the GetVgpuCapabilities method.
|
|
GetVgpuCapabilitiesFunc func(deviceVgpuCapability nvml.DeviceVgpuCapability) (bool, nvml.Return)
|
|
|
|
// GetVgpuMetadataFunc mocks the GetVgpuMetadata method.
|
|
GetVgpuMetadataFunc func() (nvml.VgpuPgpuMetadata, nvml.Return)
|
|
|
|
// GetVgpuProcessUtilizationFunc mocks the GetVgpuProcessUtilization method.
|
|
GetVgpuProcessUtilizationFunc func(v uint64) ([]nvml.VgpuProcessUtilizationSample, nvml.Return)
|
|
|
|
// GetVgpuSchedulerCapabilitiesFunc mocks the GetVgpuSchedulerCapabilities method.
|
|
GetVgpuSchedulerCapabilitiesFunc func() (nvml.VgpuSchedulerCapabilities, nvml.Return)
|
|
|
|
// GetVgpuSchedulerLogFunc mocks the GetVgpuSchedulerLog method.
|
|
GetVgpuSchedulerLogFunc func() (nvml.VgpuSchedulerLog, nvml.Return)
|
|
|
|
// GetVgpuSchedulerStateFunc mocks the GetVgpuSchedulerState method.
|
|
GetVgpuSchedulerStateFunc func() (nvml.VgpuSchedulerGetState, nvml.Return)
|
|
|
|
// GetVgpuUtilizationFunc mocks the GetVgpuUtilization method.
|
|
GetVgpuUtilizationFunc func(v uint64) (nvml.ValueType, []nvml.VgpuInstanceUtilizationSample, nvml.Return)
|
|
|
|
// GetViolationStatusFunc mocks the GetViolationStatus method.
|
|
GetViolationStatusFunc func(perfPolicyType nvml.PerfPolicyType) (nvml.ViolationTime, nvml.Return)
|
|
|
|
// GetVirtualizationModeFunc mocks the GetVirtualizationMode method.
|
|
GetVirtualizationModeFunc func() (nvml.GpuVirtualizationMode, nvml.Return)
|
|
|
|
// GpmMigSampleGetFunc mocks the GpmMigSampleGet method.
|
|
GpmMigSampleGetFunc func(n int, gpmSample nvml.GpmSample) nvml.Return
|
|
|
|
// GpmQueryDeviceSupportFunc mocks the GpmQueryDeviceSupport method.
|
|
GpmQueryDeviceSupportFunc func() (nvml.GpmSupport, nvml.Return)
|
|
|
|
// GpmQueryDeviceSupportVFunc mocks the GpmQueryDeviceSupportV method.
|
|
GpmQueryDeviceSupportVFunc func() nvml.GpmSupportV
|
|
|
|
// GpmSampleGetFunc mocks the GpmSampleGet method.
|
|
GpmSampleGetFunc func(gpmSample nvml.GpmSample) nvml.Return
|
|
|
|
// IsMigDeviceHandleFunc mocks the IsMigDeviceHandle method.
|
|
IsMigDeviceHandleFunc func() (bool, nvml.Return)
|
|
|
|
// OnSameBoardFunc mocks the OnSameBoard method.
|
|
OnSameBoardFunc func(device nvml.Device) (int, nvml.Return)
|
|
|
|
// RegisterEventsFunc mocks the RegisterEvents method.
|
|
RegisterEventsFunc func(v uint64, eventSet nvml.EventSet) nvml.Return
|
|
|
|
// ResetApplicationsClocksFunc mocks the ResetApplicationsClocks method.
|
|
ResetApplicationsClocksFunc func() nvml.Return
|
|
|
|
// ResetGpuLockedClocksFunc mocks the ResetGpuLockedClocks method.
|
|
ResetGpuLockedClocksFunc func() nvml.Return
|
|
|
|
// ResetMemoryLockedClocksFunc mocks the ResetMemoryLockedClocks method.
|
|
ResetMemoryLockedClocksFunc func() nvml.Return
|
|
|
|
// ResetNvLinkErrorCountersFunc mocks the ResetNvLinkErrorCounters method.
|
|
ResetNvLinkErrorCountersFunc func(n int) nvml.Return
|
|
|
|
// ResetNvLinkUtilizationCounterFunc mocks the ResetNvLinkUtilizationCounter method.
|
|
ResetNvLinkUtilizationCounterFunc func(n1 int, n2 int) nvml.Return
|
|
|
|
// SetAPIRestrictionFunc mocks the SetAPIRestriction method.
|
|
SetAPIRestrictionFunc func(restrictedAPI nvml.RestrictedAPI, enableState nvml.EnableState) nvml.Return
|
|
|
|
// SetAccountingModeFunc mocks the SetAccountingMode method.
|
|
SetAccountingModeFunc func(enableState nvml.EnableState) nvml.Return
|
|
|
|
// SetApplicationsClocksFunc mocks the SetApplicationsClocks method.
|
|
SetApplicationsClocksFunc func(v1 uint32, v2 uint32) nvml.Return
|
|
|
|
// SetAutoBoostedClocksEnabledFunc mocks the SetAutoBoostedClocksEnabled method.
|
|
SetAutoBoostedClocksEnabledFunc func(enableState nvml.EnableState) nvml.Return
|
|
|
|
// SetComputeModeFunc mocks the SetComputeMode method.
|
|
SetComputeModeFunc func(computeMode nvml.ComputeMode) nvml.Return
|
|
|
|
// SetCpuAffinityFunc mocks the SetCpuAffinity method.
|
|
SetCpuAffinityFunc func() nvml.Return
|
|
|
|
// SetDefaultAutoBoostedClocksEnabledFunc mocks the SetDefaultAutoBoostedClocksEnabled method.
|
|
SetDefaultAutoBoostedClocksEnabledFunc func(enableState nvml.EnableState, v uint32) nvml.Return
|
|
|
|
// SetDefaultFanSpeed_v2Func mocks the SetDefaultFanSpeed_v2 method.
|
|
SetDefaultFanSpeed_v2Func func(n int) nvml.Return
|
|
|
|
// SetDriverModelFunc mocks the SetDriverModel method.
|
|
SetDriverModelFunc func(driverModel nvml.DriverModel, v uint32) nvml.Return
|
|
|
|
// SetEccModeFunc mocks the SetEccMode method.
|
|
SetEccModeFunc func(enableState nvml.EnableState) nvml.Return
|
|
|
|
// SetFanControlPolicyFunc mocks the SetFanControlPolicy method.
|
|
SetFanControlPolicyFunc func(n int, fanControlPolicy nvml.FanControlPolicy) nvml.Return
|
|
|
|
// SetFanSpeed_v2Func mocks the SetFanSpeed_v2 method.
|
|
SetFanSpeed_v2Func func(n1 int, n2 int) nvml.Return
|
|
|
|
// SetGpcClkVfOffsetFunc mocks the SetGpcClkVfOffset method.
|
|
SetGpcClkVfOffsetFunc func(n int) nvml.Return
|
|
|
|
// SetGpuLockedClocksFunc mocks the SetGpuLockedClocks method.
|
|
SetGpuLockedClocksFunc func(v1 uint32, v2 uint32) nvml.Return
|
|
|
|
// SetGpuOperationModeFunc mocks the SetGpuOperationMode method.
|
|
SetGpuOperationModeFunc func(gpuOperationMode nvml.GpuOperationMode) nvml.Return
|
|
|
|
// SetMemClkVfOffsetFunc mocks the SetMemClkVfOffset method.
|
|
SetMemClkVfOffsetFunc func(n int) nvml.Return
|
|
|
|
// SetMemoryLockedClocksFunc mocks the SetMemoryLockedClocks method.
|
|
SetMemoryLockedClocksFunc func(v1 uint32, v2 uint32) nvml.Return
|
|
|
|
// SetMigModeFunc mocks the SetMigMode method.
|
|
SetMigModeFunc func(n int) (nvml.Return, nvml.Return)
|
|
|
|
// SetNvLinkDeviceLowPowerThresholdFunc mocks the SetNvLinkDeviceLowPowerThreshold method.
|
|
SetNvLinkDeviceLowPowerThresholdFunc func(nvLinkPowerThres *nvml.NvLinkPowerThres) nvml.Return
|
|
|
|
// SetNvLinkUtilizationControlFunc mocks the SetNvLinkUtilizationControl method.
|
|
SetNvLinkUtilizationControlFunc func(n1 int, n2 int, nvLinkUtilizationControl *nvml.NvLinkUtilizationControl, b bool) nvml.Return
|
|
|
|
// SetPersistenceModeFunc mocks the SetPersistenceMode method.
|
|
SetPersistenceModeFunc func(enableState nvml.EnableState) nvml.Return
|
|
|
|
// SetPowerManagementLimitFunc mocks the SetPowerManagementLimit method.
|
|
SetPowerManagementLimitFunc func(v uint32) nvml.Return
|
|
|
|
// SetTemperatureThresholdFunc mocks the SetTemperatureThreshold method.
|
|
SetTemperatureThresholdFunc func(temperatureThresholds nvml.TemperatureThresholds, n int) nvml.Return
|
|
|
|
// SetVgpuSchedulerStateFunc mocks the SetVgpuSchedulerState method.
|
|
SetVgpuSchedulerStateFunc func(vgpuSchedulerSetState *nvml.VgpuSchedulerSetState) nvml.Return
|
|
|
|
// SetVirtualizationModeFunc mocks the SetVirtualizationMode method.
|
|
SetVirtualizationModeFunc func(gpuVirtualizationMode nvml.GpuVirtualizationMode) nvml.Return
|
|
|
|
// ValidateInforomFunc mocks the ValidateInforom method.
|
|
ValidateInforomFunc func() nvml.Return
|
|
|
|
// VgpuTypeGetMaxInstancesFunc mocks the VgpuTypeGetMaxInstances method.
|
|
VgpuTypeGetMaxInstancesFunc func(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return)
|
|
|
|
// calls tracks calls to the methods.
|
|
calls struct {
|
|
// CcuGetStreamState holds details about calls to the CcuGetStreamState method.
|
|
CcuGetStreamState []struct {
|
|
}
|
|
// CcuSetStreamState holds details about calls to the CcuSetStreamState method.
|
|
CcuSetStreamState []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// ClearAccountingPids holds details about calls to the ClearAccountingPids method.
|
|
ClearAccountingPids []struct {
|
|
}
|
|
// ClearCpuAffinity holds details about calls to the ClearCpuAffinity method.
|
|
ClearCpuAffinity []struct {
|
|
}
|
|
// ClearEccErrorCounts holds details about calls to the ClearEccErrorCounts method.
|
|
ClearEccErrorCounts []struct {
|
|
// EccCounterType is the eccCounterType argument value.
|
|
EccCounterType nvml.EccCounterType
|
|
}
|
|
// ClearFieldValues holds details about calls to the ClearFieldValues method.
|
|
ClearFieldValues []struct {
|
|
// FieldValues is the fieldValues argument value.
|
|
FieldValues []nvml.FieldValue
|
|
}
|
|
// CreateGpuInstance holds details about calls to the CreateGpuInstance method.
|
|
CreateGpuInstance []struct {
|
|
// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
// CreateGpuInstanceWithPlacement holds details about calls to the CreateGpuInstanceWithPlacement method.
|
|
CreateGpuInstanceWithPlacement []struct {
|
|
// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
// GpuInstancePlacement is the gpuInstancePlacement argument value.
|
|
GpuInstancePlacement *nvml.GpuInstancePlacement
|
|
}
|
|
// FreezeNvLinkUtilizationCounter holds details about calls to the FreezeNvLinkUtilizationCounter method.
|
|
FreezeNvLinkUtilizationCounter []struct {
|
|
// 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
|
|
}
|
|
// GetAPIRestriction holds details about calls to the GetAPIRestriction method.
|
|
GetAPIRestriction []struct {
|
|
// RestrictedAPI is the restrictedAPI argument value.
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
}
|
|
// GetAccountingBufferSize holds details about calls to the GetAccountingBufferSize method.
|
|
GetAccountingBufferSize []struct {
|
|
}
|
|
// GetAccountingMode holds details about calls to the GetAccountingMode method.
|
|
GetAccountingMode []struct {
|
|
}
|
|
// GetAccountingPids holds details about calls to the GetAccountingPids method.
|
|
GetAccountingPids []struct {
|
|
}
|
|
// GetAccountingStats holds details about calls to the GetAccountingStats method.
|
|
GetAccountingStats []struct {
|
|
// V is the v argument value.
|
|
V uint32
|
|
}
|
|
// GetActiveVgpus holds details about calls to the GetActiveVgpus method.
|
|
GetActiveVgpus []struct {
|
|
}
|
|
// GetAdaptiveClockInfoStatus holds details about calls to the GetAdaptiveClockInfoStatus method.
|
|
GetAdaptiveClockInfoStatus []struct {
|
|
}
|
|
// GetApplicationsClock holds details about calls to the GetApplicationsClock method.
|
|
GetApplicationsClock []struct {
|
|
// ClockType is the clockType argument value.
|
|
ClockType nvml.ClockType
|
|
}
|
|
// GetArchitecture holds details about calls to the GetArchitecture method.
|
|
GetArchitecture []struct {
|
|
}
|
|
// GetAttributes holds details about calls to the GetAttributes method.
|
|
GetAttributes []struct {
|
|
}
|
|
// GetAutoBoostedClocksEnabled holds details about calls to the GetAutoBoostedClocksEnabled method.
|
|
GetAutoBoostedClocksEnabled []struct {
|
|
}
|
|
// GetBAR1MemoryInfo holds details about calls to the GetBAR1MemoryInfo method.
|
|
GetBAR1MemoryInfo []struct {
|
|
}
|
|
// GetBoardId holds details about calls to the GetBoardId method.
|
|
GetBoardId []struct {
|
|
}
|
|
// GetBoardPartNumber holds details about calls to the GetBoardPartNumber method.
|
|
GetBoardPartNumber []struct {
|
|
}
|
|
// GetBrand holds details about calls to the GetBrand method.
|
|
GetBrand []struct {
|
|
}
|
|
// GetBridgeChipInfo holds details about calls to the GetBridgeChipInfo method.
|
|
GetBridgeChipInfo []struct {
|
|
}
|
|
// GetBusType holds details about calls to the GetBusType method.
|
|
GetBusType []struct {
|
|
}
|
|
// GetClkMonStatus holds details about calls to the GetClkMonStatus method.
|
|
GetClkMonStatus []struct {
|
|
}
|
|
// GetClock holds details about calls to the GetClock method.
|
|
GetClock []struct {
|
|
// ClockType is the clockType argument value.
|
|
ClockType nvml.ClockType
|
|
// ClockId is the clockId argument value.
|
|
ClockId nvml.ClockId
|
|
}
|
|
// GetClockInfo holds details about calls to the GetClockInfo method.
|
|
GetClockInfo []struct {
|
|
// ClockType is the clockType argument value.
|
|
ClockType nvml.ClockType
|
|
}
|
|
// GetComputeInstanceId holds details about calls to the GetComputeInstanceId method.
|
|
GetComputeInstanceId []struct {
|
|
}
|
|
// GetComputeMode holds details about calls to the GetComputeMode method.
|
|
GetComputeMode []struct {
|
|
}
|
|
// GetComputeRunningProcesses holds details about calls to the GetComputeRunningProcesses method.
|
|
GetComputeRunningProcesses []struct {
|
|
}
|
|
// GetCpuAffinity holds details about calls to the GetCpuAffinity method.
|
|
GetCpuAffinity []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GetCpuAffinityWithinScope holds details about calls to the GetCpuAffinityWithinScope method.
|
|
GetCpuAffinityWithinScope []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
// AffinityScope is the affinityScope argument value.
|
|
AffinityScope nvml.AffinityScope
|
|
}
|
|
// GetCreatableVgpus holds details about calls to the GetCreatableVgpus method.
|
|
GetCreatableVgpus []struct {
|
|
}
|
|
// GetCudaComputeCapability holds details about calls to the GetCudaComputeCapability method.
|
|
GetCudaComputeCapability []struct {
|
|
}
|
|
// GetCurrPcieLinkGeneration holds details about calls to the GetCurrPcieLinkGeneration method.
|
|
GetCurrPcieLinkGeneration []struct {
|
|
}
|
|
// GetCurrPcieLinkWidth holds details about calls to the GetCurrPcieLinkWidth method.
|
|
GetCurrPcieLinkWidth []struct {
|
|
}
|
|
// GetCurrentClocksThrottleReasons holds details about calls to the GetCurrentClocksThrottleReasons method.
|
|
GetCurrentClocksThrottleReasons []struct {
|
|
}
|
|
// GetDecoderUtilization holds details about calls to the GetDecoderUtilization method.
|
|
GetDecoderUtilization []struct {
|
|
}
|
|
// GetDefaultApplicationsClock holds details about calls to the GetDefaultApplicationsClock method.
|
|
GetDefaultApplicationsClock []struct {
|
|
// ClockType is the clockType argument value.
|
|
ClockType nvml.ClockType
|
|
}
|
|
// GetDefaultEccMode holds details about calls to the GetDefaultEccMode method.
|
|
GetDefaultEccMode []struct {
|
|
}
|
|
// GetDetailedEccErrors holds details about calls to the GetDetailedEccErrors method.
|
|
GetDetailedEccErrors []struct {
|
|
// MemoryErrorType is the memoryErrorType argument value.
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
// EccCounterType is the eccCounterType argument value.
|
|
EccCounterType nvml.EccCounterType
|
|
}
|
|
// GetDeviceHandleFromMigDeviceHandle holds details about calls to the GetDeviceHandleFromMigDeviceHandle method.
|
|
GetDeviceHandleFromMigDeviceHandle []struct {
|
|
}
|
|
// GetDisplayActive holds details about calls to the GetDisplayActive method.
|
|
GetDisplayActive []struct {
|
|
}
|
|
// GetDisplayMode holds details about calls to the GetDisplayMode method.
|
|
GetDisplayMode []struct {
|
|
}
|
|
// GetDriverModel holds details about calls to the GetDriverModel method.
|
|
GetDriverModel []struct {
|
|
}
|
|
// GetDynamicPstatesInfo holds details about calls to the GetDynamicPstatesInfo method.
|
|
GetDynamicPstatesInfo []struct {
|
|
}
|
|
// GetEccMode holds details about calls to the GetEccMode method.
|
|
GetEccMode []struct {
|
|
}
|
|
// GetEncoderCapacity holds details about calls to the GetEncoderCapacity method.
|
|
GetEncoderCapacity []struct {
|
|
// EncoderType is the encoderType argument value.
|
|
EncoderType nvml.EncoderType
|
|
}
|
|
// GetEncoderSessions holds details about calls to the GetEncoderSessions method.
|
|
GetEncoderSessions []struct {
|
|
}
|
|
// GetEncoderStats holds details about calls to the GetEncoderStats method.
|
|
GetEncoderStats []struct {
|
|
}
|
|
// GetEncoderUtilization holds details about calls to the GetEncoderUtilization method.
|
|
GetEncoderUtilization []struct {
|
|
}
|
|
// GetEnforcedPowerLimit holds details about calls to the GetEnforcedPowerLimit method.
|
|
GetEnforcedPowerLimit []struct {
|
|
}
|
|
// GetFBCSessions holds details about calls to the GetFBCSessions method.
|
|
GetFBCSessions []struct {
|
|
}
|
|
// GetFBCStats holds details about calls to the GetFBCStats method.
|
|
GetFBCStats []struct {
|
|
}
|
|
// GetFanControlPolicy_v2 holds details about calls to the GetFanControlPolicy_v2 method.
|
|
GetFanControlPolicy_v2 []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GetFanSpeed holds details about calls to the GetFanSpeed method.
|
|
GetFanSpeed []struct {
|
|
}
|
|
// GetFanSpeed_v2 holds details about calls to the GetFanSpeed_v2 method.
|
|
GetFanSpeed_v2 []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GetFieldValues holds details about calls to the GetFieldValues method.
|
|
GetFieldValues []struct {
|
|
// FieldValues is the fieldValues argument value.
|
|
FieldValues []nvml.FieldValue
|
|
}
|
|
// GetGpcClkMinMaxVfOffset holds details about calls to the GetGpcClkMinMaxVfOffset method.
|
|
GetGpcClkMinMaxVfOffset []struct {
|
|
}
|
|
// GetGpcClkVfOffset holds details about calls to the GetGpcClkVfOffset method.
|
|
GetGpcClkVfOffset []struct {
|
|
}
|
|
// GetGpuFabricInfo holds details about calls to the GetGpuFabricInfo method.
|
|
GetGpuFabricInfo []struct {
|
|
}
|
|
// GetGpuInstanceById holds details about calls to the GetGpuInstanceById method.
|
|
GetGpuInstanceById []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GetGpuInstanceId holds details about calls to the GetGpuInstanceId method.
|
|
GetGpuInstanceId []struct {
|
|
}
|
|
// GetGpuInstancePossiblePlacements holds details about calls to the GetGpuInstancePossiblePlacements method.
|
|
GetGpuInstancePossiblePlacements []struct {
|
|
// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
// GetGpuInstanceProfileInfo holds details about calls to the GetGpuInstanceProfileInfo method.
|
|
GetGpuInstanceProfileInfo []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GetGpuInstanceProfileInfoV holds details about calls to the GetGpuInstanceProfileInfoV method.
|
|
GetGpuInstanceProfileInfoV []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GetGpuInstanceRemainingCapacity holds details about calls to the GetGpuInstanceRemainingCapacity method.
|
|
GetGpuInstanceRemainingCapacity []struct {
|
|
// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
// GetGpuInstances holds details about calls to the GetGpuInstances method.
|
|
GetGpuInstances []struct {
|
|
// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
// GetGpuMaxPcieLinkGeneration holds details about calls to the GetGpuMaxPcieLinkGeneration method.
|
|
GetGpuMaxPcieLinkGeneration []struct {
|
|
}
|
|
// GetGpuOperationMode holds details about calls to the GetGpuOperationMode method.
|
|
GetGpuOperationMode []struct {
|
|
}
|
|
// GetGraphicsRunningProcesses holds details about calls to the GetGraphicsRunningProcesses method.
|
|
GetGraphicsRunningProcesses []struct {
|
|
}
|
|
// GetGridLicensableFeatures holds details about calls to the GetGridLicensableFeatures method.
|
|
GetGridLicensableFeatures []struct {
|
|
}
|
|
// GetGspFirmwareMode holds details about calls to the GetGspFirmwareMode method.
|
|
GetGspFirmwareMode []struct {
|
|
}
|
|
// GetGspFirmwareVersion holds details about calls to the GetGspFirmwareVersion method.
|
|
GetGspFirmwareVersion []struct {
|
|
}
|
|
// GetHostVgpuMode holds details about calls to the GetHostVgpuMode method.
|
|
GetHostVgpuMode []struct {
|
|
}
|
|
// GetIndex holds details about calls to the GetIndex method.
|
|
GetIndex []struct {
|
|
}
|
|
// GetInforomConfigurationChecksum holds details about calls to the GetInforomConfigurationChecksum method.
|
|
GetInforomConfigurationChecksum []struct {
|
|
}
|
|
// GetInforomImageVersion holds details about calls to the GetInforomImageVersion method.
|
|
GetInforomImageVersion []struct {
|
|
}
|
|
// GetInforomVersion holds details about calls to the GetInforomVersion method.
|
|
GetInforomVersion []struct {
|
|
// InforomObject is the inforomObject argument value.
|
|
InforomObject nvml.InforomObject
|
|
}
|
|
// GetIrqNum holds details about calls to the GetIrqNum method.
|
|
GetIrqNum []struct {
|
|
}
|
|
// GetMPSComputeRunningProcesses holds details about calls to the GetMPSComputeRunningProcesses method.
|
|
GetMPSComputeRunningProcesses []struct {
|
|
}
|
|
// GetMaxClockInfo holds details about calls to the GetMaxClockInfo method.
|
|
GetMaxClockInfo []struct {
|
|
// ClockType is the clockType argument value.
|
|
ClockType nvml.ClockType
|
|
}
|
|
// GetMaxCustomerBoostClock holds details about calls to the GetMaxCustomerBoostClock method.
|
|
GetMaxCustomerBoostClock []struct {
|
|
// ClockType is the clockType argument value.
|
|
ClockType nvml.ClockType
|
|
}
|
|
// GetMaxMigDeviceCount holds details about calls to the GetMaxMigDeviceCount method.
|
|
GetMaxMigDeviceCount []struct {
|
|
}
|
|
// GetMaxPcieLinkGeneration holds details about calls to the GetMaxPcieLinkGeneration method.
|
|
GetMaxPcieLinkGeneration []struct {
|
|
}
|
|
// GetMaxPcieLinkWidth holds details about calls to the GetMaxPcieLinkWidth method.
|
|
GetMaxPcieLinkWidth []struct {
|
|
}
|
|
// GetMemClkMinMaxVfOffset holds details about calls to the GetMemClkMinMaxVfOffset method.
|
|
GetMemClkMinMaxVfOffset []struct {
|
|
}
|
|
// GetMemClkVfOffset holds details about calls to the GetMemClkVfOffset method.
|
|
GetMemClkVfOffset []struct {
|
|
}
|
|
// GetMemoryAffinity holds details about calls to the GetMemoryAffinity method.
|
|
GetMemoryAffinity []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
// AffinityScope is the affinityScope argument value.
|
|
AffinityScope nvml.AffinityScope
|
|
}
|
|
// GetMemoryBusWidth holds details about calls to the GetMemoryBusWidth method.
|
|
GetMemoryBusWidth []struct {
|
|
}
|
|
// GetMemoryErrorCounter holds details about calls to the GetMemoryErrorCounter method.
|
|
GetMemoryErrorCounter []struct {
|
|
// 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
|
|
}
|
|
// GetMemoryInfo holds details about calls to the GetMemoryInfo method.
|
|
GetMemoryInfo []struct {
|
|
}
|
|
// GetMemoryInfo_v2 holds details about calls to the GetMemoryInfo_v2 method.
|
|
GetMemoryInfo_v2 []struct {
|
|
}
|
|
// GetMigDeviceHandleByIndex holds details about calls to the GetMigDeviceHandleByIndex method.
|
|
GetMigDeviceHandleByIndex []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GetMigMode holds details about calls to the GetMigMode method.
|
|
GetMigMode []struct {
|
|
}
|
|
// GetMinMaxClockOfPState holds details about calls to the GetMinMaxClockOfPState method.
|
|
GetMinMaxClockOfPState []struct {
|
|
// ClockType is the clockType argument value.
|
|
ClockType nvml.ClockType
|
|
// Pstates is the pstates argument value.
|
|
Pstates nvml.Pstates
|
|
}
|
|
// GetMinMaxFanSpeed holds details about calls to the GetMinMaxFanSpeed method.
|
|
GetMinMaxFanSpeed []struct {
|
|
}
|
|
// GetMinorNumber holds details about calls to the GetMinorNumber method.
|
|
GetMinorNumber []struct {
|
|
}
|
|
// GetMultiGpuBoard holds details about calls to the GetMultiGpuBoard method.
|
|
GetMultiGpuBoard []struct {
|
|
}
|
|
// GetName holds details about calls to the GetName method.
|
|
GetName []struct {
|
|
}
|
|
// GetNumFans holds details about calls to the GetNumFans method.
|
|
GetNumFans []struct {
|
|
}
|
|
// GetNumGpuCores holds details about calls to the GetNumGpuCores method.
|
|
GetNumGpuCores []struct {
|
|
}
|
|
// GetNvLinkCapability holds details about calls to the GetNvLinkCapability method.
|
|
GetNvLinkCapability []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
// NvLinkCapability is the nvLinkCapability argument value.
|
|
NvLinkCapability nvml.NvLinkCapability
|
|
}
|
|
// GetNvLinkErrorCounter holds details about calls to the GetNvLinkErrorCounter method.
|
|
GetNvLinkErrorCounter []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
// NvLinkErrorCounter is the nvLinkErrorCounter argument value.
|
|
NvLinkErrorCounter nvml.NvLinkErrorCounter
|
|
}
|
|
// GetNvLinkRemoteDeviceType holds details about calls to the GetNvLinkRemoteDeviceType method.
|
|
GetNvLinkRemoteDeviceType []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GetNvLinkRemotePciInfo holds details about calls to the GetNvLinkRemotePciInfo method.
|
|
GetNvLinkRemotePciInfo []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GetNvLinkState holds details about calls to the GetNvLinkState method.
|
|
GetNvLinkState []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GetNvLinkUtilizationControl holds details about calls to the GetNvLinkUtilizationControl method.
|
|
GetNvLinkUtilizationControl []struct {
|
|
// N1 is the n1 argument value.
|
|
N1 int
|
|
// N2 is the n2 argument value.
|
|
N2 int
|
|
}
|
|
// GetNvLinkUtilizationCounter holds details about calls to the GetNvLinkUtilizationCounter method.
|
|
GetNvLinkUtilizationCounter []struct {
|
|
// N1 is the n1 argument value.
|
|
N1 int
|
|
// N2 is the n2 argument value.
|
|
N2 int
|
|
}
|
|
// GetNvLinkVersion holds details about calls to the GetNvLinkVersion method.
|
|
GetNvLinkVersion []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GetP2PStatus holds details about calls to the GetP2PStatus method.
|
|
GetP2PStatus []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
// GpuP2PCapsIndex is the gpuP2PCapsIndex argument value.
|
|
GpuP2PCapsIndex nvml.GpuP2PCapsIndex
|
|
}
|
|
// GetPciInfo holds details about calls to the GetPciInfo method.
|
|
GetPciInfo []struct {
|
|
}
|
|
// GetPcieLinkMaxSpeed holds details about calls to the GetPcieLinkMaxSpeed method.
|
|
GetPcieLinkMaxSpeed []struct {
|
|
}
|
|
// GetPcieReplayCounter holds details about calls to the GetPcieReplayCounter method.
|
|
GetPcieReplayCounter []struct {
|
|
}
|
|
// GetPcieSpeed holds details about calls to the GetPcieSpeed method.
|
|
GetPcieSpeed []struct {
|
|
}
|
|
// GetPcieThroughput holds details about calls to the GetPcieThroughput method.
|
|
GetPcieThroughput []struct {
|
|
// PcieUtilCounter is the pcieUtilCounter argument value.
|
|
PcieUtilCounter nvml.PcieUtilCounter
|
|
}
|
|
// GetPerformanceState holds details about calls to the GetPerformanceState method.
|
|
GetPerformanceState []struct {
|
|
}
|
|
// GetPersistenceMode holds details about calls to the GetPersistenceMode method.
|
|
GetPersistenceMode []struct {
|
|
}
|
|
// GetPgpuMetadataString holds details about calls to the GetPgpuMetadataString method.
|
|
GetPgpuMetadataString []struct {
|
|
}
|
|
// GetPowerManagementDefaultLimit holds details about calls to the GetPowerManagementDefaultLimit method.
|
|
GetPowerManagementDefaultLimit []struct {
|
|
}
|
|
// GetPowerManagementLimit holds details about calls to the GetPowerManagementLimit method.
|
|
GetPowerManagementLimit []struct {
|
|
}
|
|
// GetPowerManagementLimitConstraints holds details about calls to the GetPowerManagementLimitConstraints method.
|
|
GetPowerManagementLimitConstraints []struct {
|
|
}
|
|
// GetPowerManagementMode holds details about calls to the GetPowerManagementMode method.
|
|
GetPowerManagementMode []struct {
|
|
}
|
|
// GetPowerSource holds details about calls to the GetPowerSource method.
|
|
GetPowerSource []struct {
|
|
}
|
|
// GetPowerState holds details about calls to the GetPowerState method.
|
|
GetPowerState []struct {
|
|
}
|
|
// GetPowerUsage holds details about calls to the GetPowerUsage method.
|
|
GetPowerUsage []struct {
|
|
}
|
|
// GetProcessUtilization holds details about calls to the GetProcessUtilization method.
|
|
GetProcessUtilization []struct {
|
|
// V is the v argument value.
|
|
V uint64
|
|
}
|
|
// GetRemappedRows holds details about calls to the GetRemappedRows method.
|
|
GetRemappedRows []struct {
|
|
}
|
|
// GetRetiredPages holds details about calls to the GetRetiredPages method.
|
|
GetRetiredPages []struct {
|
|
// PageRetirementCause is the pageRetirementCause argument value.
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
}
|
|
// GetRetiredPagesPendingStatus holds details about calls to the GetRetiredPagesPendingStatus method.
|
|
GetRetiredPagesPendingStatus []struct {
|
|
}
|
|
// GetRetiredPages_v2 holds details about calls to the GetRetiredPages_v2 method.
|
|
GetRetiredPages_v2 []struct {
|
|
// PageRetirementCause is the pageRetirementCause argument value.
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
}
|
|
// GetRowRemapperHistogram holds details about calls to the GetRowRemapperHistogram method.
|
|
GetRowRemapperHistogram []struct {
|
|
}
|
|
// GetSamples holds details about calls to the GetSamples method.
|
|
GetSamples []struct {
|
|
// SamplingType is the samplingType argument value.
|
|
SamplingType nvml.SamplingType
|
|
// V is the v argument value.
|
|
V uint64
|
|
}
|
|
// GetSerial holds details about calls to the GetSerial method.
|
|
GetSerial []struct {
|
|
}
|
|
// GetSupportedClocksThrottleReasons holds details about calls to the GetSupportedClocksThrottleReasons method.
|
|
GetSupportedClocksThrottleReasons []struct {
|
|
}
|
|
// GetSupportedEventTypes holds details about calls to the GetSupportedEventTypes method.
|
|
GetSupportedEventTypes []struct {
|
|
}
|
|
// GetSupportedGraphicsClocks holds details about calls to the GetSupportedGraphicsClocks method.
|
|
GetSupportedGraphicsClocks []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GetSupportedMemoryClocks holds details about calls to the GetSupportedMemoryClocks method.
|
|
GetSupportedMemoryClocks []struct {
|
|
}
|
|
// GetSupportedPerformanceStates holds details about calls to the GetSupportedPerformanceStates method.
|
|
GetSupportedPerformanceStates []struct {
|
|
}
|
|
// GetSupportedVgpus holds details about calls to the GetSupportedVgpus method.
|
|
GetSupportedVgpus []struct {
|
|
}
|
|
// GetTargetFanSpeed holds details about calls to the GetTargetFanSpeed method.
|
|
GetTargetFanSpeed []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// GetTemperature holds details about calls to the GetTemperature method.
|
|
GetTemperature []struct {
|
|
// TemperatureSensors is the temperatureSensors argument value.
|
|
TemperatureSensors nvml.TemperatureSensors
|
|
}
|
|
// GetTemperatureThreshold holds details about calls to the GetTemperatureThreshold method.
|
|
GetTemperatureThreshold []struct {
|
|
// TemperatureThresholds is the temperatureThresholds argument value.
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
}
|
|
// GetThermalSettings holds details about calls to the GetThermalSettings method.
|
|
GetThermalSettings []struct {
|
|
// V is the v argument value.
|
|
V uint32
|
|
}
|
|
// GetTopologyCommonAncestor holds details about calls to the GetTopologyCommonAncestor method.
|
|
GetTopologyCommonAncestor []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// GetTopologyNearestGpus holds details about calls to the GetTopologyNearestGpus method.
|
|
GetTopologyNearestGpus []struct {
|
|
// GpuTopologyLevel is the gpuTopologyLevel argument value.
|
|
GpuTopologyLevel nvml.GpuTopologyLevel
|
|
}
|
|
// GetTotalEccErrors holds details about calls to the GetTotalEccErrors method.
|
|
GetTotalEccErrors []struct {
|
|
// MemoryErrorType is the memoryErrorType argument value.
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
// EccCounterType is the eccCounterType argument value.
|
|
EccCounterType nvml.EccCounterType
|
|
}
|
|
// GetTotalEnergyConsumption holds details about calls to the GetTotalEnergyConsumption method.
|
|
GetTotalEnergyConsumption []struct {
|
|
}
|
|
// GetUUID holds details about calls to the GetUUID method.
|
|
GetUUID []struct {
|
|
}
|
|
// GetUtilizationRates holds details about calls to the GetUtilizationRates method.
|
|
GetUtilizationRates []struct {
|
|
}
|
|
// GetVbiosVersion holds details about calls to the GetVbiosVersion method.
|
|
GetVbiosVersion []struct {
|
|
}
|
|
// GetVgpuCapabilities holds details about calls to the GetVgpuCapabilities method.
|
|
GetVgpuCapabilities []struct {
|
|
// DeviceVgpuCapability is the deviceVgpuCapability argument value.
|
|
DeviceVgpuCapability nvml.DeviceVgpuCapability
|
|
}
|
|
// GetVgpuMetadata holds details about calls to the GetVgpuMetadata method.
|
|
GetVgpuMetadata []struct {
|
|
}
|
|
// GetVgpuProcessUtilization holds details about calls to the GetVgpuProcessUtilization method.
|
|
GetVgpuProcessUtilization []struct {
|
|
// V is the v argument value.
|
|
V uint64
|
|
}
|
|
// GetVgpuSchedulerCapabilities holds details about calls to the GetVgpuSchedulerCapabilities method.
|
|
GetVgpuSchedulerCapabilities []struct {
|
|
}
|
|
// GetVgpuSchedulerLog holds details about calls to the GetVgpuSchedulerLog method.
|
|
GetVgpuSchedulerLog []struct {
|
|
}
|
|
// GetVgpuSchedulerState holds details about calls to the GetVgpuSchedulerState method.
|
|
GetVgpuSchedulerState []struct {
|
|
}
|
|
// GetVgpuUtilization holds details about calls to the GetVgpuUtilization method.
|
|
GetVgpuUtilization []struct {
|
|
// V is the v argument value.
|
|
V uint64
|
|
}
|
|
// GetViolationStatus holds details about calls to the GetViolationStatus method.
|
|
GetViolationStatus []struct {
|
|
// PerfPolicyType is the perfPolicyType argument value.
|
|
PerfPolicyType nvml.PerfPolicyType
|
|
}
|
|
// GetVirtualizationMode holds details about calls to the GetVirtualizationMode method.
|
|
GetVirtualizationMode []struct {
|
|
}
|
|
// GpmMigSampleGet holds details about calls to the GpmMigSampleGet method.
|
|
GpmMigSampleGet []struct {
|
|
// 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 {
|
|
}
|
|
// GpmQueryDeviceSupportV holds details about calls to the GpmQueryDeviceSupportV method.
|
|
GpmQueryDeviceSupportV []struct {
|
|
}
|
|
// GpmSampleGet holds details about calls to the GpmSampleGet method.
|
|
GpmSampleGet []struct {
|
|
// GpmSample is the gpmSample argument value.
|
|
GpmSample nvml.GpmSample
|
|
}
|
|
// IsMigDeviceHandle holds details about calls to the IsMigDeviceHandle method.
|
|
IsMigDeviceHandle []struct {
|
|
}
|
|
// OnSameBoard holds details about calls to the OnSameBoard method.
|
|
OnSameBoard []struct {
|
|
// Device is the device argument value.
|
|
Device nvml.Device
|
|
}
|
|
// RegisterEvents holds details about calls to the RegisterEvents method.
|
|
RegisterEvents []struct {
|
|
// V is the v argument value.
|
|
V uint64
|
|
// EventSet is the eventSet argument value.
|
|
EventSet nvml.EventSet
|
|
}
|
|
// ResetApplicationsClocks holds details about calls to the ResetApplicationsClocks method.
|
|
ResetApplicationsClocks []struct {
|
|
}
|
|
// ResetGpuLockedClocks holds details about calls to the ResetGpuLockedClocks method.
|
|
ResetGpuLockedClocks []struct {
|
|
}
|
|
// ResetMemoryLockedClocks holds details about calls to the ResetMemoryLockedClocks method.
|
|
ResetMemoryLockedClocks []struct {
|
|
}
|
|
// ResetNvLinkErrorCounters holds details about calls to the ResetNvLinkErrorCounters method.
|
|
ResetNvLinkErrorCounters []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// ResetNvLinkUtilizationCounter holds details about calls to the ResetNvLinkUtilizationCounter method.
|
|
ResetNvLinkUtilizationCounter []struct {
|
|
// N1 is the n1 argument value.
|
|
N1 int
|
|
// N2 is the n2 argument value.
|
|
N2 int
|
|
}
|
|
// SetAPIRestriction holds details about calls to the SetAPIRestriction method.
|
|
SetAPIRestriction []struct {
|
|
// RestrictedAPI is the restrictedAPI argument value.
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
// EnableState is the enableState argument value.
|
|
EnableState nvml.EnableState
|
|
}
|
|
// SetAccountingMode holds details about calls to the SetAccountingMode method.
|
|
SetAccountingMode []struct {
|
|
// EnableState is the enableState argument value.
|
|
EnableState nvml.EnableState
|
|
}
|
|
// SetApplicationsClocks holds details about calls to the SetApplicationsClocks method.
|
|
SetApplicationsClocks []struct {
|
|
// V1 is the v1 argument value.
|
|
V1 uint32
|
|
// V2 is the v2 argument value.
|
|
V2 uint32
|
|
}
|
|
// SetAutoBoostedClocksEnabled holds details about calls to the SetAutoBoostedClocksEnabled method.
|
|
SetAutoBoostedClocksEnabled []struct {
|
|
// EnableState is the enableState argument value.
|
|
EnableState nvml.EnableState
|
|
}
|
|
// SetComputeMode holds details about calls to the SetComputeMode method.
|
|
SetComputeMode []struct {
|
|
// ComputeMode is the computeMode argument value.
|
|
ComputeMode nvml.ComputeMode
|
|
}
|
|
// SetCpuAffinity holds details about calls to the SetCpuAffinity method.
|
|
SetCpuAffinity []struct {
|
|
}
|
|
// SetDefaultAutoBoostedClocksEnabled holds details about calls to the SetDefaultAutoBoostedClocksEnabled method.
|
|
SetDefaultAutoBoostedClocksEnabled []struct {
|
|
// EnableState is the enableState argument value.
|
|
EnableState nvml.EnableState
|
|
// V is the v argument value.
|
|
V uint32
|
|
}
|
|
// SetDefaultFanSpeed_v2 holds details about calls to the SetDefaultFanSpeed_v2 method.
|
|
SetDefaultFanSpeed_v2 []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// SetDriverModel holds details about calls to the SetDriverModel method.
|
|
SetDriverModel []struct {
|
|
// DriverModel is the driverModel argument value.
|
|
DriverModel nvml.DriverModel
|
|
// V is the v argument value.
|
|
V uint32
|
|
}
|
|
// SetEccMode holds details about calls to the SetEccMode method.
|
|
SetEccMode []struct {
|
|
// EnableState is the enableState argument value.
|
|
EnableState nvml.EnableState
|
|
}
|
|
// SetFanControlPolicy holds details about calls to the SetFanControlPolicy method.
|
|
SetFanControlPolicy []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
// FanControlPolicy is the fanControlPolicy argument value.
|
|
FanControlPolicy nvml.FanControlPolicy
|
|
}
|
|
// SetFanSpeed_v2 holds details about calls to the SetFanSpeed_v2 method.
|
|
SetFanSpeed_v2 []struct {
|
|
// N1 is the n1 argument value.
|
|
N1 int
|
|
// N2 is the n2 argument value.
|
|
N2 int
|
|
}
|
|
// SetGpcClkVfOffset holds details about calls to the SetGpcClkVfOffset method.
|
|
SetGpcClkVfOffset []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// SetGpuLockedClocks holds details about calls to the SetGpuLockedClocks method.
|
|
SetGpuLockedClocks []struct {
|
|
// V1 is the v1 argument value.
|
|
V1 uint32
|
|
// V2 is the v2 argument value.
|
|
V2 uint32
|
|
}
|
|
// SetGpuOperationMode holds details about calls to the SetGpuOperationMode method.
|
|
SetGpuOperationMode []struct {
|
|
// GpuOperationMode is the gpuOperationMode argument value.
|
|
GpuOperationMode nvml.GpuOperationMode
|
|
}
|
|
// SetMemClkVfOffset holds details about calls to the SetMemClkVfOffset method.
|
|
SetMemClkVfOffset []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// SetMemoryLockedClocks holds details about calls to the SetMemoryLockedClocks method.
|
|
SetMemoryLockedClocks []struct {
|
|
// V1 is the v1 argument value.
|
|
V1 uint32
|
|
// V2 is the v2 argument value.
|
|
V2 uint32
|
|
}
|
|
// SetMigMode holds details about calls to the SetMigMode method.
|
|
SetMigMode []struct {
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// SetNvLinkDeviceLowPowerThreshold holds details about calls to the SetNvLinkDeviceLowPowerThreshold method.
|
|
SetNvLinkDeviceLowPowerThreshold []struct {
|
|
// NvLinkPowerThres is the nvLinkPowerThres argument value.
|
|
NvLinkPowerThres *nvml.NvLinkPowerThres
|
|
}
|
|
// SetNvLinkUtilizationControl holds details about calls to the SetNvLinkUtilizationControl method.
|
|
SetNvLinkUtilizationControl []struct {
|
|
// 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
|
|
}
|
|
// SetPersistenceMode holds details about calls to the SetPersistenceMode method.
|
|
SetPersistenceMode []struct {
|
|
// EnableState is the enableState argument value.
|
|
EnableState nvml.EnableState
|
|
}
|
|
// SetPowerManagementLimit holds details about calls to the SetPowerManagementLimit method.
|
|
SetPowerManagementLimit []struct {
|
|
// V is the v argument value.
|
|
V uint32
|
|
}
|
|
// SetTemperatureThreshold holds details about calls to the SetTemperatureThreshold method.
|
|
SetTemperatureThreshold []struct {
|
|
// TemperatureThresholds is the temperatureThresholds argument value.
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
// N is the n argument value.
|
|
N int
|
|
}
|
|
// SetVgpuSchedulerState holds details about calls to the SetVgpuSchedulerState method.
|
|
SetVgpuSchedulerState []struct {
|
|
// VgpuSchedulerSetState is the vgpuSchedulerSetState argument value.
|
|
VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
|
|
}
|
|
// SetVirtualizationMode holds details about calls to the SetVirtualizationMode method.
|
|
SetVirtualizationMode []struct {
|
|
// GpuVirtualizationMode is the gpuVirtualizationMode argument value.
|
|
GpuVirtualizationMode nvml.GpuVirtualizationMode
|
|
}
|
|
// ValidateInforom holds details about calls to the ValidateInforom method.
|
|
ValidateInforom []struct {
|
|
}
|
|
// VgpuTypeGetMaxInstances holds details about calls to the VgpuTypeGetMaxInstances method.
|
|
VgpuTypeGetMaxInstances []struct {
|
|
// VgpuTypeId is the vgpuTypeId argument value.
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
}
|
|
lockCcuGetStreamState sync.RWMutex
|
|
lockCcuSetStreamState sync.RWMutex
|
|
lockClearAccountingPids sync.RWMutex
|
|
lockClearCpuAffinity sync.RWMutex
|
|
lockClearEccErrorCounts sync.RWMutex
|
|
lockClearFieldValues sync.RWMutex
|
|
lockCreateGpuInstance sync.RWMutex
|
|
lockCreateGpuInstanceWithPlacement sync.RWMutex
|
|
lockFreezeNvLinkUtilizationCounter sync.RWMutex
|
|
lockGetAPIRestriction sync.RWMutex
|
|
lockGetAccountingBufferSize sync.RWMutex
|
|
lockGetAccountingMode sync.RWMutex
|
|
lockGetAccountingPids sync.RWMutex
|
|
lockGetAccountingStats sync.RWMutex
|
|
lockGetActiveVgpus sync.RWMutex
|
|
lockGetAdaptiveClockInfoStatus sync.RWMutex
|
|
lockGetApplicationsClock sync.RWMutex
|
|
lockGetArchitecture sync.RWMutex
|
|
lockGetAttributes sync.RWMutex
|
|
lockGetAutoBoostedClocksEnabled sync.RWMutex
|
|
lockGetBAR1MemoryInfo sync.RWMutex
|
|
lockGetBoardId sync.RWMutex
|
|
lockGetBoardPartNumber sync.RWMutex
|
|
lockGetBrand sync.RWMutex
|
|
lockGetBridgeChipInfo sync.RWMutex
|
|
lockGetBusType sync.RWMutex
|
|
lockGetClkMonStatus sync.RWMutex
|
|
lockGetClock sync.RWMutex
|
|
lockGetClockInfo sync.RWMutex
|
|
lockGetComputeInstanceId sync.RWMutex
|
|
lockGetComputeMode sync.RWMutex
|
|
lockGetComputeRunningProcesses sync.RWMutex
|
|
lockGetCpuAffinity sync.RWMutex
|
|
lockGetCpuAffinityWithinScope sync.RWMutex
|
|
lockGetCreatableVgpus sync.RWMutex
|
|
lockGetCudaComputeCapability sync.RWMutex
|
|
lockGetCurrPcieLinkGeneration sync.RWMutex
|
|
lockGetCurrPcieLinkWidth sync.RWMutex
|
|
lockGetCurrentClocksThrottleReasons sync.RWMutex
|
|
lockGetDecoderUtilization sync.RWMutex
|
|
lockGetDefaultApplicationsClock sync.RWMutex
|
|
lockGetDefaultEccMode sync.RWMutex
|
|
lockGetDetailedEccErrors sync.RWMutex
|
|
lockGetDeviceHandleFromMigDeviceHandle sync.RWMutex
|
|
lockGetDisplayActive sync.RWMutex
|
|
lockGetDisplayMode sync.RWMutex
|
|
lockGetDriverModel sync.RWMutex
|
|
lockGetDynamicPstatesInfo sync.RWMutex
|
|
lockGetEccMode sync.RWMutex
|
|
lockGetEncoderCapacity sync.RWMutex
|
|
lockGetEncoderSessions sync.RWMutex
|
|
lockGetEncoderStats sync.RWMutex
|
|
lockGetEncoderUtilization sync.RWMutex
|
|
lockGetEnforcedPowerLimit sync.RWMutex
|
|
lockGetFBCSessions sync.RWMutex
|
|
lockGetFBCStats sync.RWMutex
|
|
lockGetFanControlPolicy_v2 sync.RWMutex
|
|
lockGetFanSpeed sync.RWMutex
|
|
lockGetFanSpeed_v2 sync.RWMutex
|
|
lockGetFieldValues sync.RWMutex
|
|
lockGetGpcClkMinMaxVfOffset sync.RWMutex
|
|
lockGetGpcClkVfOffset sync.RWMutex
|
|
lockGetGpuFabricInfo sync.RWMutex
|
|
lockGetGpuInstanceById sync.RWMutex
|
|
lockGetGpuInstanceId sync.RWMutex
|
|
lockGetGpuInstancePossiblePlacements sync.RWMutex
|
|
lockGetGpuInstanceProfileInfo sync.RWMutex
|
|
lockGetGpuInstanceProfileInfoV sync.RWMutex
|
|
lockGetGpuInstanceRemainingCapacity sync.RWMutex
|
|
lockGetGpuInstances sync.RWMutex
|
|
lockGetGpuMaxPcieLinkGeneration sync.RWMutex
|
|
lockGetGpuOperationMode sync.RWMutex
|
|
lockGetGraphicsRunningProcesses sync.RWMutex
|
|
lockGetGridLicensableFeatures sync.RWMutex
|
|
lockGetGspFirmwareMode sync.RWMutex
|
|
lockGetGspFirmwareVersion sync.RWMutex
|
|
lockGetHostVgpuMode sync.RWMutex
|
|
lockGetIndex sync.RWMutex
|
|
lockGetInforomConfigurationChecksum sync.RWMutex
|
|
lockGetInforomImageVersion sync.RWMutex
|
|
lockGetInforomVersion sync.RWMutex
|
|
lockGetIrqNum sync.RWMutex
|
|
lockGetMPSComputeRunningProcesses sync.RWMutex
|
|
lockGetMaxClockInfo sync.RWMutex
|
|
lockGetMaxCustomerBoostClock sync.RWMutex
|
|
lockGetMaxMigDeviceCount sync.RWMutex
|
|
lockGetMaxPcieLinkGeneration sync.RWMutex
|
|
lockGetMaxPcieLinkWidth sync.RWMutex
|
|
lockGetMemClkMinMaxVfOffset sync.RWMutex
|
|
lockGetMemClkVfOffset sync.RWMutex
|
|
lockGetMemoryAffinity sync.RWMutex
|
|
lockGetMemoryBusWidth sync.RWMutex
|
|
lockGetMemoryErrorCounter sync.RWMutex
|
|
lockGetMemoryInfo sync.RWMutex
|
|
lockGetMemoryInfo_v2 sync.RWMutex
|
|
lockGetMigDeviceHandleByIndex sync.RWMutex
|
|
lockGetMigMode sync.RWMutex
|
|
lockGetMinMaxClockOfPState sync.RWMutex
|
|
lockGetMinMaxFanSpeed sync.RWMutex
|
|
lockGetMinorNumber sync.RWMutex
|
|
lockGetMultiGpuBoard sync.RWMutex
|
|
lockGetName sync.RWMutex
|
|
lockGetNumFans sync.RWMutex
|
|
lockGetNumGpuCores sync.RWMutex
|
|
lockGetNvLinkCapability sync.RWMutex
|
|
lockGetNvLinkErrorCounter sync.RWMutex
|
|
lockGetNvLinkRemoteDeviceType sync.RWMutex
|
|
lockGetNvLinkRemotePciInfo sync.RWMutex
|
|
lockGetNvLinkState sync.RWMutex
|
|
lockGetNvLinkUtilizationControl sync.RWMutex
|
|
lockGetNvLinkUtilizationCounter sync.RWMutex
|
|
lockGetNvLinkVersion sync.RWMutex
|
|
lockGetP2PStatus sync.RWMutex
|
|
lockGetPciInfo sync.RWMutex
|
|
lockGetPcieLinkMaxSpeed sync.RWMutex
|
|
lockGetPcieReplayCounter sync.RWMutex
|
|
lockGetPcieSpeed sync.RWMutex
|
|
lockGetPcieThroughput sync.RWMutex
|
|
lockGetPerformanceState sync.RWMutex
|
|
lockGetPersistenceMode sync.RWMutex
|
|
lockGetPgpuMetadataString sync.RWMutex
|
|
lockGetPowerManagementDefaultLimit sync.RWMutex
|
|
lockGetPowerManagementLimit sync.RWMutex
|
|
lockGetPowerManagementLimitConstraints sync.RWMutex
|
|
lockGetPowerManagementMode sync.RWMutex
|
|
lockGetPowerSource sync.RWMutex
|
|
lockGetPowerState sync.RWMutex
|
|
lockGetPowerUsage sync.RWMutex
|
|
lockGetProcessUtilization sync.RWMutex
|
|
lockGetRemappedRows sync.RWMutex
|
|
lockGetRetiredPages sync.RWMutex
|
|
lockGetRetiredPagesPendingStatus sync.RWMutex
|
|
lockGetRetiredPages_v2 sync.RWMutex
|
|
lockGetRowRemapperHistogram sync.RWMutex
|
|
lockGetSamples sync.RWMutex
|
|
lockGetSerial sync.RWMutex
|
|
lockGetSupportedClocksThrottleReasons sync.RWMutex
|
|
lockGetSupportedEventTypes sync.RWMutex
|
|
lockGetSupportedGraphicsClocks sync.RWMutex
|
|
lockGetSupportedMemoryClocks sync.RWMutex
|
|
lockGetSupportedPerformanceStates sync.RWMutex
|
|
lockGetSupportedVgpus sync.RWMutex
|
|
lockGetTargetFanSpeed sync.RWMutex
|
|
lockGetTemperature sync.RWMutex
|
|
lockGetTemperatureThreshold sync.RWMutex
|
|
lockGetThermalSettings sync.RWMutex
|
|
lockGetTopologyCommonAncestor sync.RWMutex
|
|
lockGetTopologyNearestGpus sync.RWMutex
|
|
lockGetTotalEccErrors sync.RWMutex
|
|
lockGetTotalEnergyConsumption sync.RWMutex
|
|
lockGetUUID sync.RWMutex
|
|
lockGetUtilizationRates sync.RWMutex
|
|
lockGetVbiosVersion sync.RWMutex
|
|
lockGetVgpuCapabilities sync.RWMutex
|
|
lockGetVgpuMetadata sync.RWMutex
|
|
lockGetVgpuProcessUtilization sync.RWMutex
|
|
lockGetVgpuSchedulerCapabilities sync.RWMutex
|
|
lockGetVgpuSchedulerLog sync.RWMutex
|
|
lockGetVgpuSchedulerState sync.RWMutex
|
|
lockGetVgpuUtilization sync.RWMutex
|
|
lockGetViolationStatus sync.RWMutex
|
|
lockGetVirtualizationMode sync.RWMutex
|
|
lockGpmMigSampleGet sync.RWMutex
|
|
lockGpmQueryDeviceSupport sync.RWMutex
|
|
lockGpmQueryDeviceSupportV sync.RWMutex
|
|
lockGpmSampleGet sync.RWMutex
|
|
lockIsMigDeviceHandle sync.RWMutex
|
|
lockOnSameBoard sync.RWMutex
|
|
lockRegisterEvents sync.RWMutex
|
|
lockResetApplicationsClocks sync.RWMutex
|
|
lockResetGpuLockedClocks sync.RWMutex
|
|
lockResetMemoryLockedClocks sync.RWMutex
|
|
lockResetNvLinkErrorCounters sync.RWMutex
|
|
lockResetNvLinkUtilizationCounter sync.RWMutex
|
|
lockSetAPIRestriction sync.RWMutex
|
|
lockSetAccountingMode sync.RWMutex
|
|
lockSetApplicationsClocks sync.RWMutex
|
|
lockSetAutoBoostedClocksEnabled sync.RWMutex
|
|
lockSetComputeMode sync.RWMutex
|
|
lockSetCpuAffinity sync.RWMutex
|
|
lockSetDefaultAutoBoostedClocksEnabled sync.RWMutex
|
|
lockSetDefaultFanSpeed_v2 sync.RWMutex
|
|
lockSetDriverModel sync.RWMutex
|
|
lockSetEccMode sync.RWMutex
|
|
lockSetFanControlPolicy sync.RWMutex
|
|
lockSetFanSpeed_v2 sync.RWMutex
|
|
lockSetGpcClkVfOffset sync.RWMutex
|
|
lockSetGpuLockedClocks sync.RWMutex
|
|
lockSetGpuOperationMode sync.RWMutex
|
|
lockSetMemClkVfOffset sync.RWMutex
|
|
lockSetMemoryLockedClocks sync.RWMutex
|
|
lockSetMigMode sync.RWMutex
|
|
lockSetNvLinkDeviceLowPowerThreshold sync.RWMutex
|
|
lockSetNvLinkUtilizationControl sync.RWMutex
|
|
lockSetPersistenceMode sync.RWMutex
|
|
lockSetPowerManagementLimit sync.RWMutex
|
|
lockSetTemperatureThreshold sync.RWMutex
|
|
lockSetVgpuSchedulerState sync.RWMutex
|
|
lockSetVirtualizationMode sync.RWMutex
|
|
lockValidateInforom sync.RWMutex
|
|
lockVgpuTypeGetMaxInstances sync.RWMutex
|
|
}
|
|
|
|
// CcuGetStreamState calls CcuGetStreamStateFunc.
|
|
func (mock *Device) CcuGetStreamState() (int, nvml.Return) {
|
|
if mock.CcuGetStreamStateFunc == nil {
|
|
panic("Device.CcuGetStreamStateFunc: method is nil but Device.CcuGetStreamState was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockCcuGetStreamState.Lock()
|
|
mock.calls.CcuGetStreamState = append(mock.calls.CcuGetStreamState, callInfo)
|
|
mock.lockCcuGetStreamState.Unlock()
|
|
return mock.CcuGetStreamStateFunc()
|
|
}
|
|
|
|
// CcuGetStreamStateCalls gets all the calls that were made to CcuGetStreamState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.CcuGetStreamStateCalls())
|
|
func (mock *Device) CcuGetStreamStateCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockCcuGetStreamState.RLock()
|
|
calls = mock.calls.CcuGetStreamState
|
|
mock.lockCcuGetStreamState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// CcuSetStreamState calls CcuSetStreamStateFunc.
|
|
func (mock *Device) CcuSetStreamState(n int) nvml.Return {
|
|
if mock.CcuSetStreamStateFunc == nil {
|
|
panic("Device.CcuSetStreamStateFunc: method is nil but Device.CcuSetStreamState was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockCcuSetStreamState.Lock()
|
|
mock.calls.CcuSetStreamState = append(mock.calls.CcuSetStreamState, callInfo)
|
|
mock.lockCcuSetStreamState.Unlock()
|
|
return mock.CcuSetStreamStateFunc(n)
|
|
}
|
|
|
|
// CcuSetStreamStateCalls gets all the calls that were made to CcuSetStreamState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.CcuSetStreamStateCalls())
|
|
func (mock *Device) CcuSetStreamStateCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockCcuSetStreamState.RLock()
|
|
calls = mock.calls.CcuSetStreamState
|
|
mock.lockCcuSetStreamState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// ClearAccountingPids calls ClearAccountingPidsFunc.
|
|
func (mock *Device) ClearAccountingPids() nvml.Return {
|
|
if mock.ClearAccountingPidsFunc == nil {
|
|
panic("Device.ClearAccountingPidsFunc: method is nil but Device.ClearAccountingPids was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockClearAccountingPids.Lock()
|
|
mock.calls.ClearAccountingPids = append(mock.calls.ClearAccountingPids, callInfo)
|
|
mock.lockClearAccountingPids.Unlock()
|
|
return mock.ClearAccountingPidsFunc()
|
|
}
|
|
|
|
// ClearAccountingPidsCalls gets all the calls that were made to ClearAccountingPids.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.ClearAccountingPidsCalls())
|
|
func (mock *Device) ClearAccountingPidsCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockClearAccountingPids.RLock()
|
|
calls = mock.calls.ClearAccountingPids
|
|
mock.lockClearAccountingPids.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// ClearCpuAffinity calls ClearCpuAffinityFunc.
|
|
func (mock *Device) ClearCpuAffinity() nvml.Return {
|
|
if mock.ClearCpuAffinityFunc == nil {
|
|
panic("Device.ClearCpuAffinityFunc: method is nil but Device.ClearCpuAffinity was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockClearCpuAffinity.Lock()
|
|
mock.calls.ClearCpuAffinity = append(mock.calls.ClearCpuAffinity, callInfo)
|
|
mock.lockClearCpuAffinity.Unlock()
|
|
return mock.ClearCpuAffinityFunc()
|
|
}
|
|
|
|
// ClearCpuAffinityCalls gets all the calls that were made to ClearCpuAffinity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.ClearCpuAffinityCalls())
|
|
func (mock *Device) ClearCpuAffinityCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockClearCpuAffinity.RLock()
|
|
calls = mock.calls.ClearCpuAffinity
|
|
mock.lockClearCpuAffinity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// ClearEccErrorCounts calls ClearEccErrorCountsFunc.
|
|
func (mock *Device) ClearEccErrorCounts(eccCounterType nvml.EccCounterType) nvml.Return {
|
|
if mock.ClearEccErrorCountsFunc == nil {
|
|
panic("Device.ClearEccErrorCountsFunc: method is nil but Device.ClearEccErrorCounts was just called")
|
|
}
|
|
callInfo := struct {
|
|
EccCounterType nvml.EccCounterType
|
|
}{
|
|
EccCounterType: eccCounterType,
|
|
}
|
|
mock.lockClearEccErrorCounts.Lock()
|
|
mock.calls.ClearEccErrorCounts = append(mock.calls.ClearEccErrorCounts, callInfo)
|
|
mock.lockClearEccErrorCounts.Unlock()
|
|
return mock.ClearEccErrorCountsFunc(eccCounterType)
|
|
}
|
|
|
|
// ClearEccErrorCountsCalls gets all the calls that were made to ClearEccErrorCounts.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.ClearEccErrorCountsCalls())
|
|
func (mock *Device) ClearEccErrorCountsCalls() []struct {
|
|
EccCounterType nvml.EccCounterType
|
|
} {
|
|
var calls []struct {
|
|
EccCounterType nvml.EccCounterType
|
|
}
|
|
mock.lockClearEccErrorCounts.RLock()
|
|
calls = mock.calls.ClearEccErrorCounts
|
|
mock.lockClearEccErrorCounts.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// ClearFieldValues calls ClearFieldValuesFunc.
|
|
func (mock *Device) ClearFieldValues(fieldValues []nvml.FieldValue) nvml.Return {
|
|
if mock.ClearFieldValuesFunc == nil {
|
|
panic("Device.ClearFieldValuesFunc: method is nil but Device.ClearFieldValues was just called")
|
|
}
|
|
callInfo := struct {
|
|
FieldValues []nvml.FieldValue
|
|
}{
|
|
FieldValues: fieldValues,
|
|
}
|
|
mock.lockClearFieldValues.Lock()
|
|
mock.calls.ClearFieldValues = append(mock.calls.ClearFieldValues, callInfo)
|
|
mock.lockClearFieldValues.Unlock()
|
|
return mock.ClearFieldValuesFunc(fieldValues)
|
|
}
|
|
|
|
// ClearFieldValuesCalls gets all the calls that were made to ClearFieldValues.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.ClearFieldValuesCalls())
|
|
func (mock *Device) ClearFieldValuesCalls() []struct {
|
|
FieldValues []nvml.FieldValue
|
|
} {
|
|
var calls []struct {
|
|
FieldValues []nvml.FieldValue
|
|
}
|
|
mock.lockClearFieldValues.RLock()
|
|
calls = mock.calls.ClearFieldValues
|
|
mock.lockClearFieldValues.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// CreateGpuInstance calls CreateGpuInstanceFunc.
|
|
func (mock *Device) CreateGpuInstance(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (nvml.GpuInstance, nvml.Return) {
|
|
if mock.CreateGpuInstanceFunc == nil {
|
|
panic("Device.CreateGpuInstanceFunc: method is nil but Device.CreateGpuInstance was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}{
|
|
GpuInstanceProfileInfo: gpuInstanceProfileInfo,
|
|
}
|
|
mock.lockCreateGpuInstance.Lock()
|
|
mock.calls.CreateGpuInstance = append(mock.calls.CreateGpuInstance, callInfo)
|
|
mock.lockCreateGpuInstance.Unlock()
|
|
return mock.CreateGpuInstanceFunc(gpuInstanceProfileInfo)
|
|
}
|
|
|
|
// CreateGpuInstanceCalls gets all the calls that were made to CreateGpuInstance.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.CreateGpuInstanceCalls())
|
|
func (mock *Device) CreateGpuInstanceCalls() []struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
} {
|
|
var calls []struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
mock.lockCreateGpuInstance.RLock()
|
|
calls = mock.calls.CreateGpuInstance
|
|
mock.lockCreateGpuInstance.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// CreateGpuInstanceWithPlacement calls CreateGpuInstanceWithPlacementFunc.
|
|
func (mock *Device) CreateGpuInstanceWithPlacement(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo, gpuInstancePlacement *nvml.GpuInstancePlacement) (nvml.GpuInstance, nvml.Return) {
|
|
if mock.CreateGpuInstanceWithPlacementFunc == nil {
|
|
panic("Device.CreateGpuInstanceWithPlacementFunc: method is nil but Device.CreateGpuInstanceWithPlacement was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
GpuInstancePlacement *nvml.GpuInstancePlacement
|
|
}{
|
|
GpuInstanceProfileInfo: gpuInstanceProfileInfo,
|
|
GpuInstancePlacement: gpuInstancePlacement,
|
|
}
|
|
mock.lockCreateGpuInstanceWithPlacement.Lock()
|
|
mock.calls.CreateGpuInstanceWithPlacement = append(mock.calls.CreateGpuInstanceWithPlacement, callInfo)
|
|
mock.lockCreateGpuInstanceWithPlacement.Unlock()
|
|
return mock.CreateGpuInstanceWithPlacementFunc(gpuInstanceProfileInfo, gpuInstancePlacement)
|
|
}
|
|
|
|
// CreateGpuInstanceWithPlacementCalls gets all the calls that were made to CreateGpuInstanceWithPlacement.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.CreateGpuInstanceWithPlacementCalls())
|
|
func (mock *Device) CreateGpuInstanceWithPlacementCalls() []struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
GpuInstancePlacement *nvml.GpuInstancePlacement
|
|
} {
|
|
var calls []struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
GpuInstancePlacement *nvml.GpuInstancePlacement
|
|
}
|
|
mock.lockCreateGpuInstanceWithPlacement.RLock()
|
|
calls = mock.calls.CreateGpuInstanceWithPlacement
|
|
mock.lockCreateGpuInstanceWithPlacement.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// FreezeNvLinkUtilizationCounter calls FreezeNvLinkUtilizationCounterFunc.
|
|
func (mock *Device) FreezeNvLinkUtilizationCounter(n1 int, n2 int, enableState nvml.EnableState) nvml.Return {
|
|
if mock.FreezeNvLinkUtilizationCounterFunc == nil {
|
|
panic("Device.FreezeNvLinkUtilizationCounterFunc: method is nil but Device.FreezeNvLinkUtilizationCounter was just called")
|
|
}
|
|
callInfo := struct {
|
|
N1 int
|
|
N2 int
|
|
EnableState nvml.EnableState
|
|
}{
|
|
N1: n1,
|
|
N2: n2,
|
|
EnableState: enableState,
|
|
}
|
|
mock.lockFreezeNvLinkUtilizationCounter.Lock()
|
|
mock.calls.FreezeNvLinkUtilizationCounter = append(mock.calls.FreezeNvLinkUtilizationCounter, callInfo)
|
|
mock.lockFreezeNvLinkUtilizationCounter.Unlock()
|
|
return mock.FreezeNvLinkUtilizationCounterFunc(n1, n2, enableState)
|
|
}
|
|
|
|
// FreezeNvLinkUtilizationCounterCalls gets all the calls that were made to FreezeNvLinkUtilizationCounter.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.FreezeNvLinkUtilizationCounterCalls())
|
|
func (mock *Device) FreezeNvLinkUtilizationCounterCalls() []struct {
|
|
N1 int
|
|
N2 int
|
|
EnableState nvml.EnableState
|
|
} {
|
|
var calls []struct {
|
|
N1 int
|
|
N2 int
|
|
EnableState nvml.EnableState
|
|
}
|
|
mock.lockFreezeNvLinkUtilizationCounter.RLock()
|
|
calls = mock.calls.FreezeNvLinkUtilizationCounter
|
|
mock.lockFreezeNvLinkUtilizationCounter.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetAPIRestriction calls GetAPIRestrictionFunc.
|
|
func (mock *Device) GetAPIRestriction(restrictedAPI nvml.RestrictedAPI) (nvml.EnableState, nvml.Return) {
|
|
if mock.GetAPIRestrictionFunc == nil {
|
|
panic("Device.GetAPIRestrictionFunc: method is nil but Device.GetAPIRestriction was just called")
|
|
}
|
|
callInfo := struct {
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
}{
|
|
RestrictedAPI: restrictedAPI,
|
|
}
|
|
mock.lockGetAPIRestriction.Lock()
|
|
mock.calls.GetAPIRestriction = append(mock.calls.GetAPIRestriction, callInfo)
|
|
mock.lockGetAPIRestriction.Unlock()
|
|
return mock.GetAPIRestrictionFunc(restrictedAPI)
|
|
}
|
|
|
|
// GetAPIRestrictionCalls gets all the calls that were made to GetAPIRestriction.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetAPIRestrictionCalls())
|
|
func (mock *Device) GetAPIRestrictionCalls() []struct {
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
} {
|
|
var calls []struct {
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
}
|
|
mock.lockGetAPIRestriction.RLock()
|
|
calls = mock.calls.GetAPIRestriction
|
|
mock.lockGetAPIRestriction.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetAccountingBufferSize calls GetAccountingBufferSizeFunc.
|
|
func (mock *Device) GetAccountingBufferSize() (int, nvml.Return) {
|
|
if mock.GetAccountingBufferSizeFunc == nil {
|
|
panic("Device.GetAccountingBufferSizeFunc: method is nil but Device.GetAccountingBufferSize was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetAccountingBufferSize.Lock()
|
|
mock.calls.GetAccountingBufferSize = append(mock.calls.GetAccountingBufferSize, callInfo)
|
|
mock.lockGetAccountingBufferSize.Unlock()
|
|
return mock.GetAccountingBufferSizeFunc()
|
|
}
|
|
|
|
// GetAccountingBufferSizeCalls gets all the calls that were made to GetAccountingBufferSize.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetAccountingBufferSizeCalls())
|
|
func (mock *Device) GetAccountingBufferSizeCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetAccountingBufferSize.RLock()
|
|
calls = mock.calls.GetAccountingBufferSize
|
|
mock.lockGetAccountingBufferSize.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetAccountingMode calls GetAccountingModeFunc.
|
|
func (mock *Device) GetAccountingMode() (nvml.EnableState, nvml.Return) {
|
|
if mock.GetAccountingModeFunc == nil {
|
|
panic("Device.GetAccountingModeFunc: method is nil but Device.GetAccountingMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetAccountingMode.Lock()
|
|
mock.calls.GetAccountingMode = append(mock.calls.GetAccountingMode, callInfo)
|
|
mock.lockGetAccountingMode.Unlock()
|
|
return mock.GetAccountingModeFunc()
|
|
}
|
|
|
|
// GetAccountingModeCalls gets all the calls that were made to GetAccountingMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetAccountingModeCalls())
|
|
func (mock *Device) GetAccountingModeCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetAccountingMode.RLock()
|
|
calls = mock.calls.GetAccountingMode
|
|
mock.lockGetAccountingMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetAccountingPids calls GetAccountingPidsFunc.
|
|
func (mock *Device) GetAccountingPids() ([]int, nvml.Return) {
|
|
if mock.GetAccountingPidsFunc == nil {
|
|
panic("Device.GetAccountingPidsFunc: method is nil but Device.GetAccountingPids was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetAccountingPids.Lock()
|
|
mock.calls.GetAccountingPids = append(mock.calls.GetAccountingPids, callInfo)
|
|
mock.lockGetAccountingPids.Unlock()
|
|
return mock.GetAccountingPidsFunc()
|
|
}
|
|
|
|
// GetAccountingPidsCalls gets all the calls that were made to GetAccountingPids.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetAccountingPidsCalls())
|
|
func (mock *Device) GetAccountingPidsCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetAccountingPids.RLock()
|
|
calls = mock.calls.GetAccountingPids
|
|
mock.lockGetAccountingPids.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetAccountingStats calls GetAccountingStatsFunc.
|
|
func (mock *Device) GetAccountingStats(v uint32) (nvml.AccountingStats, nvml.Return) {
|
|
if mock.GetAccountingStatsFunc == nil {
|
|
panic("Device.GetAccountingStatsFunc: method is nil but Device.GetAccountingStats was just called")
|
|
}
|
|
callInfo := struct {
|
|
V uint32
|
|
}{
|
|
V: v,
|
|
}
|
|
mock.lockGetAccountingStats.Lock()
|
|
mock.calls.GetAccountingStats = append(mock.calls.GetAccountingStats, callInfo)
|
|
mock.lockGetAccountingStats.Unlock()
|
|
return mock.GetAccountingStatsFunc(v)
|
|
}
|
|
|
|
// GetAccountingStatsCalls gets all the calls that were made to GetAccountingStats.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetAccountingStatsCalls())
|
|
func (mock *Device) GetAccountingStatsCalls() []struct {
|
|
V uint32
|
|
} {
|
|
var calls []struct {
|
|
V uint32
|
|
}
|
|
mock.lockGetAccountingStats.RLock()
|
|
calls = mock.calls.GetAccountingStats
|
|
mock.lockGetAccountingStats.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetActiveVgpus calls GetActiveVgpusFunc.
|
|
func (mock *Device) GetActiveVgpus() ([]nvml.VgpuInstance, nvml.Return) {
|
|
if mock.GetActiveVgpusFunc == nil {
|
|
panic("Device.GetActiveVgpusFunc: method is nil but Device.GetActiveVgpus was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetActiveVgpus.Lock()
|
|
mock.calls.GetActiveVgpus = append(mock.calls.GetActiveVgpus, callInfo)
|
|
mock.lockGetActiveVgpus.Unlock()
|
|
return mock.GetActiveVgpusFunc()
|
|
}
|
|
|
|
// GetActiveVgpusCalls gets all the calls that were made to GetActiveVgpus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetActiveVgpusCalls())
|
|
func (mock *Device) GetActiveVgpusCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetActiveVgpus.RLock()
|
|
calls = mock.calls.GetActiveVgpus
|
|
mock.lockGetActiveVgpus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetAdaptiveClockInfoStatus calls GetAdaptiveClockInfoStatusFunc.
|
|
func (mock *Device) GetAdaptiveClockInfoStatus() (uint32, nvml.Return) {
|
|
if mock.GetAdaptiveClockInfoStatusFunc == nil {
|
|
panic("Device.GetAdaptiveClockInfoStatusFunc: method is nil but Device.GetAdaptiveClockInfoStatus was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetAdaptiveClockInfoStatus.Lock()
|
|
mock.calls.GetAdaptiveClockInfoStatus = append(mock.calls.GetAdaptiveClockInfoStatus, callInfo)
|
|
mock.lockGetAdaptiveClockInfoStatus.Unlock()
|
|
return mock.GetAdaptiveClockInfoStatusFunc()
|
|
}
|
|
|
|
// GetAdaptiveClockInfoStatusCalls gets all the calls that were made to GetAdaptiveClockInfoStatus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetAdaptiveClockInfoStatusCalls())
|
|
func (mock *Device) GetAdaptiveClockInfoStatusCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetAdaptiveClockInfoStatus.RLock()
|
|
calls = mock.calls.GetAdaptiveClockInfoStatus
|
|
mock.lockGetAdaptiveClockInfoStatus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetApplicationsClock calls GetApplicationsClockFunc.
|
|
func (mock *Device) GetApplicationsClock(clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
if mock.GetApplicationsClockFunc == nil {
|
|
panic("Device.GetApplicationsClockFunc: method is nil but Device.GetApplicationsClock was just called")
|
|
}
|
|
callInfo := struct {
|
|
ClockType nvml.ClockType
|
|
}{
|
|
ClockType: clockType,
|
|
}
|
|
mock.lockGetApplicationsClock.Lock()
|
|
mock.calls.GetApplicationsClock = append(mock.calls.GetApplicationsClock, callInfo)
|
|
mock.lockGetApplicationsClock.Unlock()
|
|
return mock.GetApplicationsClockFunc(clockType)
|
|
}
|
|
|
|
// GetApplicationsClockCalls gets all the calls that were made to GetApplicationsClock.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetApplicationsClockCalls())
|
|
func (mock *Device) GetApplicationsClockCalls() []struct {
|
|
ClockType nvml.ClockType
|
|
} {
|
|
var calls []struct {
|
|
ClockType nvml.ClockType
|
|
}
|
|
mock.lockGetApplicationsClock.RLock()
|
|
calls = mock.calls.GetApplicationsClock
|
|
mock.lockGetApplicationsClock.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetArchitecture calls GetArchitectureFunc.
|
|
func (mock *Device) GetArchitecture() (nvml.DeviceArchitecture, nvml.Return) {
|
|
if mock.GetArchitectureFunc == nil {
|
|
panic("Device.GetArchitectureFunc: method is nil but Device.GetArchitecture was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetArchitecture.Lock()
|
|
mock.calls.GetArchitecture = append(mock.calls.GetArchitecture, callInfo)
|
|
mock.lockGetArchitecture.Unlock()
|
|
return mock.GetArchitectureFunc()
|
|
}
|
|
|
|
// GetArchitectureCalls gets all the calls that were made to GetArchitecture.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetArchitectureCalls())
|
|
func (mock *Device) GetArchitectureCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetArchitecture.RLock()
|
|
calls = mock.calls.GetArchitecture
|
|
mock.lockGetArchitecture.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetAttributes calls GetAttributesFunc.
|
|
func (mock *Device) GetAttributes() (nvml.DeviceAttributes, nvml.Return) {
|
|
if mock.GetAttributesFunc == nil {
|
|
panic("Device.GetAttributesFunc: method is nil but Device.GetAttributes was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetAttributes.Lock()
|
|
mock.calls.GetAttributes = append(mock.calls.GetAttributes, callInfo)
|
|
mock.lockGetAttributes.Unlock()
|
|
return mock.GetAttributesFunc()
|
|
}
|
|
|
|
// GetAttributesCalls gets all the calls that were made to GetAttributes.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetAttributesCalls())
|
|
func (mock *Device) GetAttributesCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetAttributes.RLock()
|
|
calls = mock.calls.GetAttributes
|
|
mock.lockGetAttributes.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetAutoBoostedClocksEnabled calls GetAutoBoostedClocksEnabledFunc.
|
|
func (mock *Device) GetAutoBoostedClocksEnabled() (nvml.EnableState, nvml.EnableState, nvml.Return) {
|
|
if mock.GetAutoBoostedClocksEnabledFunc == nil {
|
|
panic("Device.GetAutoBoostedClocksEnabledFunc: method is nil but Device.GetAutoBoostedClocksEnabled was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetAutoBoostedClocksEnabled.Lock()
|
|
mock.calls.GetAutoBoostedClocksEnabled = append(mock.calls.GetAutoBoostedClocksEnabled, callInfo)
|
|
mock.lockGetAutoBoostedClocksEnabled.Unlock()
|
|
return mock.GetAutoBoostedClocksEnabledFunc()
|
|
}
|
|
|
|
// GetAutoBoostedClocksEnabledCalls gets all the calls that were made to GetAutoBoostedClocksEnabled.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetAutoBoostedClocksEnabledCalls())
|
|
func (mock *Device) GetAutoBoostedClocksEnabledCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetAutoBoostedClocksEnabled.RLock()
|
|
calls = mock.calls.GetAutoBoostedClocksEnabled
|
|
mock.lockGetAutoBoostedClocksEnabled.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetBAR1MemoryInfo calls GetBAR1MemoryInfoFunc.
|
|
func (mock *Device) GetBAR1MemoryInfo() (nvml.BAR1Memory, nvml.Return) {
|
|
if mock.GetBAR1MemoryInfoFunc == nil {
|
|
panic("Device.GetBAR1MemoryInfoFunc: method is nil but Device.GetBAR1MemoryInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetBAR1MemoryInfo.Lock()
|
|
mock.calls.GetBAR1MemoryInfo = append(mock.calls.GetBAR1MemoryInfo, callInfo)
|
|
mock.lockGetBAR1MemoryInfo.Unlock()
|
|
return mock.GetBAR1MemoryInfoFunc()
|
|
}
|
|
|
|
// GetBAR1MemoryInfoCalls gets all the calls that were made to GetBAR1MemoryInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetBAR1MemoryInfoCalls())
|
|
func (mock *Device) GetBAR1MemoryInfoCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetBAR1MemoryInfo.RLock()
|
|
calls = mock.calls.GetBAR1MemoryInfo
|
|
mock.lockGetBAR1MemoryInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetBoardId calls GetBoardIdFunc.
|
|
func (mock *Device) GetBoardId() (uint32, nvml.Return) {
|
|
if mock.GetBoardIdFunc == nil {
|
|
panic("Device.GetBoardIdFunc: method is nil but Device.GetBoardId was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetBoardId.Lock()
|
|
mock.calls.GetBoardId = append(mock.calls.GetBoardId, callInfo)
|
|
mock.lockGetBoardId.Unlock()
|
|
return mock.GetBoardIdFunc()
|
|
}
|
|
|
|
// GetBoardIdCalls gets all the calls that were made to GetBoardId.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetBoardIdCalls())
|
|
func (mock *Device) GetBoardIdCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetBoardId.RLock()
|
|
calls = mock.calls.GetBoardId
|
|
mock.lockGetBoardId.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetBoardPartNumber calls GetBoardPartNumberFunc.
|
|
func (mock *Device) GetBoardPartNumber() (string, nvml.Return) {
|
|
if mock.GetBoardPartNumberFunc == nil {
|
|
panic("Device.GetBoardPartNumberFunc: method is nil but Device.GetBoardPartNumber was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetBoardPartNumber.Lock()
|
|
mock.calls.GetBoardPartNumber = append(mock.calls.GetBoardPartNumber, callInfo)
|
|
mock.lockGetBoardPartNumber.Unlock()
|
|
return mock.GetBoardPartNumberFunc()
|
|
}
|
|
|
|
// GetBoardPartNumberCalls gets all the calls that were made to GetBoardPartNumber.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetBoardPartNumberCalls())
|
|
func (mock *Device) GetBoardPartNumberCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetBoardPartNumber.RLock()
|
|
calls = mock.calls.GetBoardPartNumber
|
|
mock.lockGetBoardPartNumber.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetBrand calls GetBrandFunc.
|
|
func (mock *Device) GetBrand() (nvml.BrandType, nvml.Return) {
|
|
if mock.GetBrandFunc == nil {
|
|
panic("Device.GetBrandFunc: method is nil but Device.GetBrand was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetBrand.Lock()
|
|
mock.calls.GetBrand = append(mock.calls.GetBrand, callInfo)
|
|
mock.lockGetBrand.Unlock()
|
|
return mock.GetBrandFunc()
|
|
}
|
|
|
|
// GetBrandCalls gets all the calls that were made to GetBrand.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetBrandCalls())
|
|
func (mock *Device) GetBrandCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetBrand.RLock()
|
|
calls = mock.calls.GetBrand
|
|
mock.lockGetBrand.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetBridgeChipInfo calls GetBridgeChipInfoFunc.
|
|
func (mock *Device) GetBridgeChipInfo() (nvml.BridgeChipHierarchy, nvml.Return) {
|
|
if mock.GetBridgeChipInfoFunc == nil {
|
|
panic("Device.GetBridgeChipInfoFunc: method is nil but Device.GetBridgeChipInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetBridgeChipInfo.Lock()
|
|
mock.calls.GetBridgeChipInfo = append(mock.calls.GetBridgeChipInfo, callInfo)
|
|
mock.lockGetBridgeChipInfo.Unlock()
|
|
return mock.GetBridgeChipInfoFunc()
|
|
}
|
|
|
|
// GetBridgeChipInfoCalls gets all the calls that were made to GetBridgeChipInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetBridgeChipInfoCalls())
|
|
func (mock *Device) GetBridgeChipInfoCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetBridgeChipInfo.RLock()
|
|
calls = mock.calls.GetBridgeChipInfo
|
|
mock.lockGetBridgeChipInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetBusType calls GetBusTypeFunc.
|
|
func (mock *Device) GetBusType() (nvml.BusType, nvml.Return) {
|
|
if mock.GetBusTypeFunc == nil {
|
|
panic("Device.GetBusTypeFunc: method is nil but Device.GetBusType was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetBusType.Lock()
|
|
mock.calls.GetBusType = append(mock.calls.GetBusType, callInfo)
|
|
mock.lockGetBusType.Unlock()
|
|
return mock.GetBusTypeFunc()
|
|
}
|
|
|
|
// GetBusTypeCalls gets all the calls that were made to GetBusType.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetBusTypeCalls())
|
|
func (mock *Device) GetBusTypeCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetBusType.RLock()
|
|
calls = mock.calls.GetBusType
|
|
mock.lockGetBusType.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetClkMonStatus calls GetClkMonStatusFunc.
|
|
func (mock *Device) GetClkMonStatus() (nvml.ClkMonStatus, nvml.Return) {
|
|
if mock.GetClkMonStatusFunc == nil {
|
|
panic("Device.GetClkMonStatusFunc: method is nil but Device.GetClkMonStatus was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetClkMonStatus.Lock()
|
|
mock.calls.GetClkMonStatus = append(mock.calls.GetClkMonStatus, callInfo)
|
|
mock.lockGetClkMonStatus.Unlock()
|
|
return mock.GetClkMonStatusFunc()
|
|
}
|
|
|
|
// GetClkMonStatusCalls gets all the calls that were made to GetClkMonStatus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetClkMonStatusCalls())
|
|
func (mock *Device) GetClkMonStatusCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetClkMonStatus.RLock()
|
|
calls = mock.calls.GetClkMonStatus
|
|
mock.lockGetClkMonStatus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetClock calls GetClockFunc.
|
|
func (mock *Device) GetClock(clockType nvml.ClockType, clockId nvml.ClockId) (uint32, nvml.Return) {
|
|
if mock.GetClockFunc == nil {
|
|
panic("Device.GetClockFunc: method is nil but Device.GetClock was just called")
|
|
}
|
|
callInfo := struct {
|
|
ClockType nvml.ClockType
|
|
ClockId nvml.ClockId
|
|
}{
|
|
ClockType: clockType,
|
|
ClockId: clockId,
|
|
}
|
|
mock.lockGetClock.Lock()
|
|
mock.calls.GetClock = append(mock.calls.GetClock, callInfo)
|
|
mock.lockGetClock.Unlock()
|
|
return mock.GetClockFunc(clockType, clockId)
|
|
}
|
|
|
|
// GetClockCalls gets all the calls that were made to GetClock.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetClockCalls())
|
|
func (mock *Device) GetClockCalls() []struct {
|
|
ClockType nvml.ClockType
|
|
ClockId nvml.ClockId
|
|
} {
|
|
var calls []struct {
|
|
ClockType nvml.ClockType
|
|
ClockId nvml.ClockId
|
|
}
|
|
mock.lockGetClock.RLock()
|
|
calls = mock.calls.GetClock
|
|
mock.lockGetClock.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetClockInfo calls GetClockInfoFunc.
|
|
func (mock *Device) GetClockInfo(clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
if mock.GetClockInfoFunc == nil {
|
|
panic("Device.GetClockInfoFunc: method is nil but Device.GetClockInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
ClockType nvml.ClockType
|
|
}{
|
|
ClockType: clockType,
|
|
}
|
|
mock.lockGetClockInfo.Lock()
|
|
mock.calls.GetClockInfo = append(mock.calls.GetClockInfo, callInfo)
|
|
mock.lockGetClockInfo.Unlock()
|
|
return mock.GetClockInfoFunc(clockType)
|
|
}
|
|
|
|
// GetClockInfoCalls gets all the calls that were made to GetClockInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetClockInfoCalls())
|
|
func (mock *Device) GetClockInfoCalls() []struct {
|
|
ClockType nvml.ClockType
|
|
} {
|
|
var calls []struct {
|
|
ClockType nvml.ClockType
|
|
}
|
|
mock.lockGetClockInfo.RLock()
|
|
calls = mock.calls.GetClockInfo
|
|
mock.lockGetClockInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetComputeInstanceId calls GetComputeInstanceIdFunc.
|
|
func (mock *Device) GetComputeInstanceId() (int, nvml.Return) {
|
|
if mock.GetComputeInstanceIdFunc == nil {
|
|
panic("Device.GetComputeInstanceIdFunc: method is nil but Device.GetComputeInstanceId was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetComputeInstanceId.Lock()
|
|
mock.calls.GetComputeInstanceId = append(mock.calls.GetComputeInstanceId, callInfo)
|
|
mock.lockGetComputeInstanceId.Unlock()
|
|
return mock.GetComputeInstanceIdFunc()
|
|
}
|
|
|
|
// GetComputeInstanceIdCalls gets all the calls that were made to GetComputeInstanceId.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetComputeInstanceIdCalls())
|
|
func (mock *Device) GetComputeInstanceIdCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetComputeInstanceId.RLock()
|
|
calls = mock.calls.GetComputeInstanceId
|
|
mock.lockGetComputeInstanceId.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetComputeMode calls GetComputeModeFunc.
|
|
func (mock *Device) GetComputeMode() (nvml.ComputeMode, nvml.Return) {
|
|
if mock.GetComputeModeFunc == nil {
|
|
panic("Device.GetComputeModeFunc: method is nil but Device.GetComputeMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetComputeMode.Lock()
|
|
mock.calls.GetComputeMode = append(mock.calls.GetComputeMode, callInfo)
|
|
mock.lockGetComputeMode.Unlock()
|
|
return mock.GetComputeModeFunc()
|
|
}
|
|
|
|
// GetComputeModeCalls gets all the calls that were made to GetComputeMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetComputeModeCalls())
|
|
func (mock *Device) GetComputeModeCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetComputeMode.RLock()
|
|
calls = mock.calls.GetComputeMode
|
|
mock.lockGetComputeMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetComputeRunningProcesses calls GetComputeRunningProcessesFunc.
|
|
func (mock *Device) GetComputeRunningProcesses() ([]nvml.ProcessInfo, nvml.Return) {
|
|
if mock.GetComputeRunningProcessesFunc == nil {
|
|
panic("Device.GetComputeRunningProcessesFunc: method is nil but Device.GetComputeRunningProcesses was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetComputeRunningProcesses.Lock()
|
|
mock.calls.GetComputeRunningProcesses = append(mock.calls.GetComputeRunningProcesses, callInfo)
|
|
mock.lockGetComputeRunningProcesses.Unlock()
|
|
return mock.GetComputeRunningProcessesFunc()
|
|
}
|
|
|
|
// GetComputeRunningProcessesCalls gets all the calls that were made to GetComputeRunningProcesses.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetComputeRunningProcessesCalls())
|
|
func (mock *Device) GetComputeRunningProcessesCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetComputeRunningProcesses.RLock()
|
|
calls = mock.calls.GetComputeRunningProcesses
|
|
mock.lockGetComputeRunningProcesses.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetCpuAffinity calls GetCpuAffinityFunc.
|
|
func (mock *Device) GetCpuAffinity(n int) ([]uint, nvml.Return) {
|
|
if mock.GetCpuAffinityFunc == nil {
|
|
panic("Device.GetCpuAffinityFunc: method is nil but Device.GetCpuAffinity was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockGetCpuAffinity.Lock()
|
|
mock.calls.GetCpuAffinity = append(mock.calls.GetCpuAffinity, callInfo)
|
|
mock.lockGetCpuAffinity.Unlock()
|
|
return mock.GetCpuAffinityFunc(n)
|
|
}
|
|
|
|
// GetCpuAffinityCalls gets all the calls that were made to GetCpuAffinity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetCpuAffinityCalls())
|
|
func (mock *Device) GetCpuAffinityCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockGetCpuAffinity.RLock()
|
|
calls = mock.calls.GetCpuAffinity
|
|
mock.lockGetCpuAffinity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetCpuAffinityWithinScope calls GetCpuAffinityWithinScopeFunc.
|
|
func (mock *Device) GetCpuAffinityWithinScope(n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return) {
|
|
if mock.GetCpuAffinityWithinScopeFunc == nil {
|
|
panic("Device.GetCpuAffinityWithinScopeFunc: method is nil but Device.GetCpuAffinityWithinScope was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
AffinityScope nvml.AffinityScope
|
|
}{
|
|
N: n,
|
|
AffinityScope: affinityScope,
|
|
}
|
|
mock.lockGetCpuAffinityWithinScope.Lock()
|
|
mock.calls.GetCpuAffinityWithinScope = append(mock.calls.GetCpuAffinityWithinScope, callInfo)
|
|
mock.lockGetCpuAffinityWithinScope.Unlock()
|
|
return mock.GetCpuAffinityWithinScopeFunc(n, affinityScope)
|
|
}
|
|
|
|
// GetCpuAffinityWithinScopeCalls gets all the calls that were made to GetCpuAffinityWithinScope.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetCpuAffinityWithinScopeCalls())
|
|
func (mock *Device) GetCpuAffinityWithinScopeCalls() []struct {
|
|
N int
|
|
AffinityScope nvml.AffinityScope
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
AffinityScope nvml.AffinityScope
|
|
}
|
|
mock.lockGetCpuAffinityWithinScope.RLock()
|
|
calls = mock.calls.GetCpuAffinityWithinScope
|
|
mock.lockGetCpuAffinityWithinScope.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetCreatableVgpus calls GetCreatableVgpusFunc.
|
|
func (mock *Device) GetCreatableVgpus() ([]nvml.VgpuTypeId, nvml.Return) {
|
|
if mock.GetCreatableVgpusFunc == nil {
|
|
panic("Device.GetCreatableVgpusFunc: method is nil but Device.GetCreatableVgpus was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetCreatableVgpus.Lock()
|
|
mock.calls.GetCreatableVgpus = append(mock.calls.GetCreatableVgpus, callInfo)
|
|
mock.lockGetCreatableVgpus.Unlock()
|
|
return mock.GetCreatableVgpusFunc()
|
|
}
|
|
|
|
// GetCreatableVgpusCalls gets all the calls that were made to GetCreatableVgpus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetCreatableVgpusCalls())
|
|
func (mock *Device) GetCreatableVgpusCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetCreatableVgpus.RLock()
|
|
calls = mock.calls.GetCreatableVgpus
|
|
mock.lockGetCreatableVgpus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetCudaComputeCapability calls GetCudaComputeCapabilityFunc.
|
|
func (mock *Device) GetCudaComputeCapability() (int, int, nvml.Return) {
|
|
if mock.GetCudaComputeCapabilityFunc == nil {
|
|
panic("Device.GetCudaComputeCapabilityFunc: method is nil but Device.GetCudaComputeCapability was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetCudaComputeCapability.Lock()
|
|
mock.calls.GetCudaComputeCapability = append(mock.calls.GetCudaComputeCapability, callInfo)
|
|
mock.lockGetCudaComputeCapability.Unlock()
|
|
return mock.GetCudaComputeCapabilityFunc()
|
|
}
|
|
|
|
// GetCudaComputeCapabilityCalls gets all the calls that were made to GetCudaComputeCapability.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetCudaComputeCapabilityCalls())
|
|
func (mock *Device) GetCudaComputeCapabilityCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetCudaComputeCapability.RLock()
|
|
calls = mock.calls.GetCudaComputeCapability
|
|
mock.lockGetCudaComputeCapability.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetCurrPcieLinkGeneration calls GetCurrPcieLinkGenerationFunc.
|
|
func (mock *Device) GetCurrPcieLinkGeneration() (int, nvml.Return) {
|
|
if mock.GetCurrPcieLinkGenerationFunc == nil {
|
|
panic("Device.GetCurrPcieLinkGenerationFunc: method is nil but Device.GetCurrPcieLinkGeneration was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetCurrPcieLinkGeneration.Lock()
|
|
mock.calls.GetCurrPcieLinkGeneration = append(mock.calls.GetCurrPcieLinkGeneration, callInfo)
|
|
mock.lockGetCurrPcieLinkGeneration.Unlock()
|
|
return mock.GetCurrPcieLinkGenerationFunc()
|
|
}
|
|
|
|
// GetCurrPcieLinkGenerationCalls gets all the calls that were made to GetCurrPcieLinkGeneration.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetCurrPcieLinkGenerationCalls())
|
|
func (mock *Device) GetCurrPcieLinkGenerationCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetCurrPcieLinkGeneration.RLock()
|
|
calls = mock.calls.GetCurrPcieLinkGeneration
|
|
mock.lockGetCurrPcieLinkGeneration.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetCurrPcieLinkWidth calls GetCurrPcieLinkWidthFunc.
|
|
func (mock *Device) GetCurrPcieLinkWidth() (int, nvml.Return) {
|
|
if mock.GetCurrPcieLinkWidthFunc == nil {
|
|
panic("Device.GetCurrPcieLinkWidthFunc: method is nil but Device.GetCurrPcieLinkWidth was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetCurrPcieLinkWidth.Lock()
|
|
mock.calls.GetCurrPcieLinkWidth = append(mock.calls.GetCurrPcieLinkWidth, callInfo)
|
|
mock.lockGetCurrPcieLinkWidth.Unlock()
|
|
return mock.GetCurrPcieLinkWidthFunc()
|
|
}
|
|
|
|
// GetCurrPcieLinkWidthCalls gets all the calls that were made to GetCurrPcieLinkWidth.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetCurrPcieLinkWidthCalls())
|
|
func (mock *Device) GetCurrPcieLinkWidthCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetCurrPcieLinkWidth.RLock()
|
|
calls = mock.calls.GetCurrPcieLinkWidth
|
|
mock.lockGetCurrPcieLinkWidth.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetCurrentClocksThrottleReasons calls GetCurrentClocksThrottleReasonsFunc.
|
|
func (mock *Device) GetCurrentClocksThrottleReasons() (uint64, nvml.Return) {
|
|
if mock.GetCurrentClocksThrottleReasonsFunc == nil {
|
|
panic("Device.GetCurrentClocksThrottleReasonsFunc: method is nil but Device.GetCurrentClocksThrottleReasons was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetCurrentClocksThrottleReasons.Lock()
|
|
mock.calls.GetCurrentClocksThrottleReasons = append(mock.calls.GetCurrentClocksThrottleReasons, callInfo)
|
|
mock.lockGetCurrentClocksThrottleReasons.Unlock()
|
|
return mock.GetCurrentClocksThrottleReasonsFunc()
|
|
}
|
|
|
|
// GetCurrentClocksThrottleReasonsCalls gets all the calls that were made to GetCurrentClocksThrottleReasons.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetCurrentClocksThrottleReasonsCalls())
|
|
func (mock *Device) GetCurrentClocksThrottleReasonsCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetCurrentClocksThrottleReasons.RLock()
|
|
calls = mock.calls.GetCurrentClocksThrottleReasons
|
|
mock.lockGetCurrentClocksThrottleReasons.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetDecoderUtilization calls GetDecoderUtilizationFunc.
|
|
func (mock *Device) GetDecoderUtilization() (uint32, uint32, nvml.Return) {
|
|
if mock.GetDecoderUtilizationFunc == nil {
|
|
panic("Device.GetDecoderUtilizationFunc: method is nil but Device.GetDecoderUtilization was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetDecoderUtilization.Lock()
|
|
mock.calls.GetDecoderUtilization = append(mock.calls.GetDecoderUtilization, callInfo)
|
|
mock.lockGetDecoderUtilization.Unlock()
|
|
return mock.GetDecoderUtilizationFunc()
|
|
}
|
|
|
|
// GetDecoderUtilizationCalls gets all the calls that were made to GetDecoderUtilization.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetDecoderUtilizationCalls())
|
|
func (mock *Device) GetDecoderUtilizationCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetDecoderUtilization.RLock()
|
|
calls = mock.calls.GetDecoderUtilization
|
|
mock.lockGetDecoderUtilization.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetDefaultApplicationsClock calls GetDefaultApplicationsClockFunc.
|
|
func (mock *Device) GetDefaultApplicationsClock(clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
if mock.GetDefaultApplicationsClockFunc == nil {
|
|
panic("Device.GetDefaultApplicationsClockFunc: method is nil but Device.GetDefaultApplicationsClock was just called")
|
|
}
|
|
callInfo := struct {
|
|
ClockType nvml.ClockType
|
|
}{
|
|
ClockType: clockType,
|
|
}
|
|
mock.lockGetDefaultApplicationsClock.Lock()
|
|
mock.calls.GetDefaultApplicationsClock = append(mock.calls.GetDefaultApplicationsClock, callInfo)
|
|
mock.lockGetDefaultApplicationsClock.Unlock()
|
|
return mock.GetDefaultApplicationsClockFunc(clockType)
|
|
}
|
|
|
|
// GetDefaultApplicationsClockCalls gets all the calls that were made to GetDefaultApplicationsClock.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetDefaultApplicationsClockCalls())
|
|
func (mock *Device) GetDefaultApplicationsClockCalls() []struct {
|
|
ClockType nvml.ClockType
|
|
} {
|
|
var calls []struct {
|
|
ClockType nvml.ClockType
|
|
}
|
|
mock.lockGetDefaultApplicationsClock.RLock()
|
|
calls = mock.calls.GetDefaultApplicationsClock
|
|
mock.lockGetDefaultApplicationsClock.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetDefaultEccMode calls GetDefaultEccModeFunc.
|
|
func (mock *Device) GetDefaultEccMode() (nvml.EnableState, nvml.Return) {
|
|
if mock.GetDefaultEccModeFunc == nil {
|
|
panic("Device.GetDefaultEccModeFunc: method is nil but Device.GetDefaultEccMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetDefaultEccMode.Lock()
|
|
mock.calls.GetDefaultEccMode = append(mock.calls.GetDefaultEccMode, callInfo)
|
|
mock.lockGetDefaultEccMode.Unlock()
|
|
return mock.GetDefaultEccModeFunc()
|
|
}
|
|
|
|
// GetDefaultEccModeCalls gets all the calls that were made to GetDefaultEccMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetDefaultEccModeCalls())
|
|
func (mock *Device) GetDefaultEccModeCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetDefaultEccMode.RLock()
|
|
calls = mock.calls.GetDefaultEccMode
|
|
mock.lockGetDefaultEccMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetDetailedEccErrors calls GetDetailedEccErrorsFunc.
|
|
func (mock *Device) GetDetailedEccErrors(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (nvml.EccErrorCounts, nvml.Return) {
|
|
if mock.GetDetailedEccErrorsFunc == nil {
|
|
panic("Device.GetDetailedEccErrorsFunc: method is nil but Device.GetDetailedEccErrors was just called")
|
|
}
|
|
callInfo := struct {
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
}{
|
|
MemoryErrorType: memoryErrorType,
|
|
EccCounterType: eccCounterType,
|
|
}
|
|
mock.lockGetDetailedEccErrors.Lock()
|
|
mock.calls.GetDetailedEccErrors = append(mock.calls.GetDetailedEccErrors, callInfo)
|
|
mock.lockGetDetailedEccErrors.Unlock()
|
|
return mock.GetDetailedEccErrorsFunc(memoryErrorType, eccCounterType)
|
|
}
|
|
|
|
// GetDetailedEccErrorsCalls gets all the calls that were made to GetDetailedEccErrors.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetDetailedEccErrorsCalls())
|
|
func (mock *Device) GetDetailedEccErrorsCalls() []struct {
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
} {
|
|
var calls []struct {
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
}
|
|
mock.lockGetDetailedEccErrors.RLock()
|
|
calls = mock.calls.GetDetailedEccErrors
|
|
mock.lockGetDetailedEccErrors.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetDeviceHandleFromMigDeviceHandle calls GetDeviceHandleFromMigDeviceHandleFunc.
|
|
func (mock *Device) GetDeviceHandleFromMigDeviceHandle() (nvml.Device, nvml.Return) {
|
|
if mock.GetDeviceHandleFromMigDeviceHandleFunc == nil {
|
|
panic("Device.GetDeviceHandleFromMigDeviceHandleFunc: method is nil but Device.GetDeviceHandleFromMigDeviceHandle was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetDeviceHandleFromMigDeviceHandle.Lock()
|
|
mock.calls.GetDeviceHandleFromMigDeviceHandle = append(mock.calls.GetDeviceHandleFromMigDeviceHandle, callInfo)
|
|
mock.lockGetDeviceHandleFromMigDeviceHandle.Unlock()
|
|
return mock.GetDeviceHandleFromMigDeviceHandleFunc()
|
|
}
|
|
|
|
// GetDeviceHandleFromMigDeviceHandleCalls gets all the calls that were made to GetDeviceHandleFromMigDeviceHandle.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetDeviceHandleFromMigDeviceHandleCalls())
|
|
func (mock *Device) GetDeviceHandleFromMigDeviceHandleCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetDeviceHandleFromMigDeviceHandle.RLock()
|
|
calls = mock.calls.GetDeviceHandleFromMigDeviceHandle
|
|
mock.lockGetDeviceHandleFromMigDeviceHandle.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetDisplayActive calls GetDisplayActiveFunc.
|
|
func (mock *Device) GetDisplayActive() (nvml.EnableState, nvml.Return) {
|
|
if mock.GetDisplayActiveFunc == nil {
|
|
panic("Device.GetDisplayActiveFunc: method is nil but Device.GetDisplayActive was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetDisplayActive.Lock()
|
|
mock.calls.GetDisplayActive = append(mock.calls.GetDisplayActive, callInfo)
|
|
mock.lockGetDisplayActive.Unlock()
|
|
return mock.GetDisplayActiveFunc()
|
|
}
|
|
|
|
// GetDisplayActiveCalls gets all the calls that were made to GetDisplayActive.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetDisplayActiveCalls())
|
|
func (mock *Device) GetDisplayActiveCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetDisplayActive.RLock()
|
|
calls = mock.calls.GetDisplayActive
|
|
mock.lockGetDisplayActive.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetDisplayMode calls GetDisplayModeFunc.
|
|
func (mock *Device) GetDisplayMode() (nvml.EnableState, nvml.Return) {
|
|
if mock.GetDisplayModeFunc == nil {
|
|
panic("Device.GetDisplayModeFunc: method is nil but Device.GetDisplayMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetDisplayMode.Lock()
|
|
mock.calls.GetDisplayMode = append(mock.calls.GetDisplayMode, callInfo)
|
|
mock.lockGetDisplayMode.Unlock()
|
|
return mock.GetDisplayModeFunc()
|
|
}
|
|
|
|
// GetDisplayModeCalls gets all the calls that were made to GetDisplayMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetDisplayModeCalls())
|
|
func (mock *Device) GetDisplayModeCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetDisplayMode.RLock()
|
|
calls = mock.calls.GetDisplayMode
|
|
mock.lockGetDisplayMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetDriverModel calls GetDriverModelFunc.
|
|
func (mock *Device) GetDriverModel() (nvml.DriverModel, nvml.DriverModel, nvml.Return) {
|
|
if mock.GetDriverModelFunc == nil {
|
|
panic("Device.GetDriverModelFunc: method is nil but Device.GetDriverModel was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetDriverModel.Lock()
|
|
mock.calls.GetDriverModel = append(mock.calls.GetDriverModel, callInfo)
|
|
mock.lockGetDriverModel.Unlock()
|
|
return mock.GetDriverModelFunc()
|
|
}
|
|
|
|
// GetDriverModelCalls gets all the calls that were made to GetDriverModel.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetDriverModelCalls())
|
|
func (mock *Device) GetDriverModelCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetDriverModel.RLock()
|
|
calls = mock.calls.GetDriverModel
|
|
mock.lockGetDriverModel.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetDynamicPstatesInfo calls GetDynamicPstatesInfoFunc.
|
|
func (mock *Device) GetDynamicPstatesInfo() (nvml.GpuDynamicPstatesInfo, nvml.Return) {
|
|
if mock.GetDynamicPstatesInfoFunc == nil {
|
|
panic("Device.GetDynamicPstatesInfoFunc: method is nil but Device.GetDynamicPstatesInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetDynamicPstatesInfo.Lock()
|
|
mock.calls.GetDynamicPstatesInfo = append(mock.calls.GetDynamicPstatesInfo, callInfo)
|
|
mock.lockGetDynamicPstatesInfo.Unlock()
|
|
return mock.GetDynamicPstatesInfoFunc()
|
|
}
|
|
|
|
// GetDynamicPstatesInfoCalls gets all the calls that were made to GetDynamicPstatesInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetDynamicPstatesInfoCalls())
|
|
func (mock *Device) GetDynamicPstatesInfoCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetDynamicPstatesInfo.RLock()
|
|
calls = mock.calls.GetDynamicPstatesInfo
|
|
mock.lockGetDynamicPstatesInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetEccMode calls GetEccModeFunc.
|
|
func (mock *Device) GetEccMode() (nvml.EnableState, nvml.EnableState, nvml.Return) {
|
|
if mock.GetEccModeFunc == nil {
|
|
panic("Device.GetEccModeFunc: method is nil but Device.GetEccMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetEccMode.Lock()
|
|
mock.calls.GetEccMode = append(mock.calls.GetEccMode, callInfo)
|
|
mock.lockGetEccMode.Unlock()
|
|
return mock.GetEccModeFunc()
|
|
}
|
|
|
|
// GetEccModeCalls gets all the calls that were made to GetEccMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetEccModeCalls())
|
|
func (mock *Device) GetEccModeCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetEccMode.RLock()
|
|
calls = mock.calls.GetEccMode
|
|
mock.lockGetEccMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetEncoderCapacity calls GetEncoderCapacityFunc.
|
|
func (mock *Device) GetEncoderCapacity(encoderType nvml.EncoderType) (int, nvml.Return) {
|
|
if mock.GetEncoderCapacityFunc == nil {
|
|
panic("Device.GetEncoderCapacityFunc: method is nil but Device.GetEncoderCapacity was just called")
|
|
}
|
|
callInfo := struct {
|
|
EncoderType nvml.EncoderType
|
|
}{
|
|
EncoderType: encoderType,
|
|
}
|
|
mock.lockGetEncoderCapacity.Lock()
|
|
mock.calls.GetEncoderCapacity = append(mock.calls.GetEncoderCapacity, callInfo)
|
|
mock.lockGetEncoderCapacity.Unlock()
|
|
return mock.GetEncoderCapacityFunc(encoderType)
|
|
}
|
|
|
|
// GetEncoderCapacityCalls gets all the calls that were made to GetEncoderCapacity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetEncoderCapacityCalls())
|
|
func (mock *Device) GetEncoderCapacityCalls() []struct {
|
|
EncoderType nvml.EncoderType
|
|
} {
|
|
var calls []struct {
|
|
EncoderType nvml.EncoderType
|
|
}
|
|
mock.lockGetEncoderCapacity.RLock()
|
|
calls = mock.calls.GetEncoderCapacity
|
|
mock.lockGetEncoderCapacity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetEncoderSessions calls GetEncoderSessionsFunc.
|
|
func (mock *Device) GetEncoderSessions() ([]nvml.EncoderSessionInfo, nvml.Return) {
|
|
if mock.GetEncoderSessionsFunc == nil {
|
|
panic("Device.GetEncoderSessionsFunc: method is nil but Device.GetEncoderSessions was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetEncoderSessions.Lock()
|
|
mock.calls.GetEncoderSessions = append(mock.calls.GetEncoderSessions, callInfo)
|
|
mock.lockGetEncoderSessions.Unlock()
|
|
return mock.GetEncoderSessionsFunc()
|
|
}
|
|
|
|
// GetEncoderSessionsCalls gets all the calls that were made to GetEncoderSessions.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetEncoderSessionsCalls())
|
|
func (mock *Device) GetEncoderSessionsCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetEncoderSessions.RLock()
|
|
calls = mock.calls.GetEncoderSessions
|
|
mock.lockGetEncoderSessions.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetEncoderStats calls GetEncoderStatsFunc.
|
|
func (mock *Device) GetEncoderStats() (int, uint32, uint32, nvml.Return) {
|
|
if mock.GetEncoderStatsFunc == nil {
|
|
panic("Device.GetEncoderStatsFunc: method is nil but Device.GetEncoderStats was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetEncoderStats.Lock()
|
|
mock.calls.GetEncoderStats = append(mock.calls.GetEncoderStats, callInfo)
|
|
mock.lockGetEncoderStats.Unlock()
|
|
return mock.GetEncoderStatsFunc()
|
|
}
|
|
|
|
// GetEncoderStatsCalls gets all the calls that were made to GetEncoderStats.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetEncoderStatsCalls())
|
|
func (mock *Device) GetEncoderStatsCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetEncoderStats.RLock()
|
|
calls = mock.calls.GetEncoderStats
|
|
mock.lockGetEncoderStats.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetEncoderUtilization calls GetEncoderUtilizationFunc.
|
|
func (mock *Device) GetEncoderUtilization() (uint32, uint32, nvml.Return) {
|
|
if mock.GetEncoderUtilizationFunc == nil {
|
|
panic("Device.GetEncoderUtilizationFunc: method is nil but Device.GetEncoderUtilization was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetEncoderUtilization.Lock()
|
|
mock.calls.GetEncoderUtilization = append(mock.calls.GetEncoderUtilization, callInfo)
|
|
mock.lockGetEncoderUtilization.Unlock()
|
|
return mock.GetEncoderUtilizationFunc()
|
|
}
|
|
|
|
// GetEncoderUtilizationCalls gets all the calls that were made to GetEncoderUtilization.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetEncoderUtilizationCalls())
|
|
func (mock *Device) GetEncoderUtilizationCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetEncoderUtilization.RLock()
|
|
calls = mock.calls.GetEncoderUtilization
|
|
mock.lockGetEncoderUtilization.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetEnforcedPowerLimit calls GetEnforcedPowerLimitFunc.
|
|
func (mock *Device) GetEnforcedPowerLimit() (uint32, nvml.Return) {
|
|
if mock.GetEnforcedPowerLimitFunc == nil {
|
|
panic("Device.GetEnforcedPowerLimitFunc: method is nil but Device.GetEnforcedPowerLimit was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetEnforcedPowerLimit.Lock()
|
|
mock.calls.GetEnforcedPowerLimit = append(mock.calls.GetEnforcedPowerLimit, callInfo)
|
|
mock.lockGetEnforcedPowerLimit.Unlock()
|
|
return mock.GetEnforcedPowerLimitFunc()
|
|
}
|
|
|
|
// GetEnforcedPowerLimitCalls gets all the calls that were made to GetEnforcedPowerLimit.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetEnforcedPowerLimitCalls())
|
|
func (mock *Device) GetEnforcedPowerLimitCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetEnforcedPowerLimit.RLock()
|
|
calls = mock.calls.GetEnforcedPowerLimit
|
|
mock.lockGetEnforcedPowerLimit.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetFBCSessions calls GetFBCSessionsFunc.
|
|
func (mock *Device) GetFBCSessions() ([]nvml.FBCSessionInfo, nvml.Return) {
|
|
if mock.GetFBCSessionsFunc == nil {
|
|
panic("Device.GetFBCSessionsFunc: method is nil but Device.GetFBCSessions was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetFBCSessions.Lock()
|
|
mock.calls.GetFBCSessions = append(mock.calls.GetFBCSessions, callInfo)
|
|
mock.lockGetFBCSessions.Unlock()
|
|
return mock.GetFBCSessionsFunc()
|
|
}
|
|
|
|
// GetFBCSessionsCalls gets all the calls that were made to GetFBCSessions.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetFBCSessionsCalls())
|
|
func (mock *Device) GetFBCSessionsCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetFBCSessions.RLock()
|
|
calls = mock.calls.GetFBCSessions
|
|
mock.lockGetFBCSessions.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetFBCStats calls GetFBCStatsFunc.
|
|
func (mock *Device) GetFBCStats() (nvml.FBCStats, nvml.Return) {
|
|
if mock.GetFBCStatsFunc == nil {
|
|
panic("Device.GetFBCStatsFunc: method is nil but Device.GetFBCStats was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetFBCStats.Lock()
|
|
mock.calls.GetFBCStats = append(mock.calls.GetFBCStats, callInfo)
|
|
mock.lockGetFBCStats.Unlock()
|
|
return mock.GetFBCStatsFunc()
|
|
}
|
|
|
|
// GetFBCStatsCalls gets all the calls that were made to GetFBCStats.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetFBCStatsCalls())
|
|
func (mock *Device) GetFBCStatsCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetFBCStats.RLock()
|
|
calls = mock.calls.GetFBCStats
|
|
mock.lockGetFBCStats.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetFanControlPolicy_v2 calls GetFanControlPolicy_v2Func.
|
|
func (mock *Device) GetFanControlPolicy_v2(n int) (nvml.FanControlPolicy, nvml.Return) {
|
|
if mock.GetFanControlPolicy_v2Func == nil {
|
|
panic("Device.GetFanControlPolicy_v2Func: method is nil but Device.GetFanControlPolicy_v2 was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockGetFanControlPolicy_v2.Lock()
|
|
mock.calls.GetFanControlPolicy_v2 = append(mock.calls.GetFanControlPolicy_v2, callInfo)
|
|
mock.lockGetFanControlPolicy_v2.Unlock()
|
|
return mock.GetFanControlPolicy_v2Func(n)
|
|
}
|
|
|
|
// GetFanControlPolicy_v2Calls gets all the calls that were made to GetFanControlPolicy_v2.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetFanControlPolicy_v2Calls())
|
|
func (mock *Device) GetFanControlPolicy_v2Calls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockGetFanControlPolicy_v2.RLock()
|
|
calls = mock.calls.GetFanControlPolicy_v2
|
|
mock.lockGetFanControlPolicy_v2.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetFanSpeed calls GetFanSpeedFunc.
|
|
func (mock *Device) GetFanSpeed() (uint32, nvml.Return) {
|
|
if mock.GetFanSpeedFunc == nil {
|
|
panic("Device.GetFanSpeedFunc: method is nil but Device.GetFanSpeed was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetFanSpeed.Lock()
|
|
mock.calls.GetFanSpeed = append(mock.calls.GetFanSpeed, callInfo)
|
|
mock.lockGetFanSpeed.Unlock()
|
|
return mock.GetFanSpeedFunc()
|
|
}
|
|
|
|
// GetFanSpeedCalls gets all the calls that were made to GetFanSpeed.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetFanSpeedCalls())
|
|
func (mock *Device) GetFanSpeedCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetFanSpeed.RLock()
|
|
calls = mock.calls.GetFanSpeed
|
|
mock.lockGetFanSpeed.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetFanSpeed_v2 calls GetFanSpeed_v2Func.
|
|
func (mock *Device) GetFanSpeed_v2(n int) (uint32, nvml.Return) {
|
|
if mock.GetFanSpeed_v2Func == nil {
|
|
panic("Device.GetFanSpeed_v2Func: method is nil but Device.GetFanSpeed_v2 was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockGetFanSpeed_v2.Lock()
|
|
mock.calls.GetFanSpeed_v2 = append(mock.calls.GetFanSpeed_v2, callInfo)
|
|
mock.lockGetFanSpeed_v2.Unlock()
|
|
return mock.GetFanSpeed_v2Func(n)
|
|
}
|
|
|
|
// GetFanSpeed_v2Calls gets all the calls that were made to GetFanSpeed_v2.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetFanSpeed_v2Calls())
|
|
func (mock *Device) GetFanSpeed_v2Calls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockGetFanSpeed_v2.RLock()
|
|
calls = mock.calls.GetFanSpeed_v2
|
|
mock.lockGetFanSpeed_v2.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetFieldValues calls GetFieldValuesFunc.
|
|
func (mock *Device) GetFieldValues(fieldValues []nvml.FieldValue) nvml.Return {
|
|
if mock.GetFieldValuesFunc == nil {
|
|
panic("Device.GetFieldValuesFunc: method is nil but Device.GetFieldValues was just called")
|
|
}
|
|
callInfo := struct {
|
|
FieldValues []nvml.FieldValue
|
|
}{
|
|
FieldValues: fieldValues,
|
|
}
|
|
mock.lockGetFieldValues.Lock()
|
|
mock.calls.GetFieldValues = append(mock.calls.GetFieldValues, callInfo)
|
|
mock.lockGetFieldValues.Unlock()
|
|
return mock.GetFieldValuesFunc(fieldValues)
|
|
}
|
|
|
|
// GetFieldValuesCalls gets all the calls that were made to GetFieldValues.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetFieldValuesCalls())
|
|
func (mock *Device) GetFieldValuesCalls() []struct {
|
|
FieldValues []nvml.FieldValue
|
|
} {
|
|
var calls []struct {
|
|
FieldValues []nvml.FieldValue
|
|
}
|
|
mock.lockGetFieldValues.RLock()
|
|
calls = mock.calls.GetFieldValues
|
|
mock.lockGetFieldValues.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGpcClkMinMaxVfOffset calls GetGpcClkMinMaxVfOffsetFunc.
|
|
func (mock *Device) GetGpcClkMinMaxVfOffset() (int, int, nvml.Return) {
|
|
if mock.GetGpcClkMinMaxVfOffsetFunc == nil {
|
|
panic("Device.GetGpcClkMinMaxVfOffsetFunc: method is nil but Device.GetGpcClkMinMaxVfOffset was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetGpcClkMinMaxVfOffset.Lock()
|
|
mock.calls.GetGpcClkMinMaxVfOffset = append(mock.calls.GetGpcClkMinMaxVfOffset, callInfo)
|
|
mock.lockGetGpcClkMinMaxVfOffset.Unlock()
|
|
return mock.GetGpcClkMinMaxVfOffsetFunc()
|
|
}
|
|
|
|
// GetGpcClkMinMaxVfOffsetCalls gets all the calls that were made to GetGpcClkMinMaxVfOffset.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGpcClkMinMaxVfOffsetCalls())
|
|
func (mock *Device) GetGpcClkMinMaxVfOffsetCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetGpcClkMinMaxVfOffset.RLock()
|
|
calls = mock.calls.GetGpcClkMinMaxVfOffset
|
|
mock.lockGetGpcClkMinMaxVfOffset.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGpcClkVfOffset calls GetGpcClkVfOffsetFunc.
|
|
func (mock *Device) GetGpcClkVfOffset() (int, nvml.Return) {
|
|
if mock.GetGpcClkVfOffsetFunc == nil {
|
|
panic("Device.GetGpcClkVfOffsetFunc: method is nil but Device.GetGpcClkVfOffset was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetGpcClkVfOffset.Lock()
|
|
mock.calls.GetGpcClkVfOffset = append(mock.calls.GetGpcClkVfOffset, callInfo)
|
|
mock.lockGetGpcClkVfOffset.Unlock()
|
|
return mock.GetGpcClkVfOffsetFunc()
|
|
}
|
|
|
|
// GetGpcClkVfOffsetCalls gets all the calls that were made to GetGpcClkVfOffset.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGpcClkVfOffsetCalls())
|
|
func (mock *Device) GetGpcClkVfOffsetCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetGpcClkVfOffset.RLock()
|
|
calls = mock.calls.GetGpcClkVfOffset
|
|
mock.lockGetGpcClkVfOffset.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGpuFabricInfo calls GetGpuFabricInfoFunc.
|
|
func (mock *Device) GetGpuFabricInfo() (nvml.GpuFabricInfo, nvml.Return) {
|
|
if mock.GetGpuFabricInfoFunc == nil {
|
|
panic("Device.GetGpuFabricInfoFunc: method is nil but Device.GetGpuFabricInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetGpuFabricInfo.Lock()
|
|
mock.calls.GetGpuFabricInfo = append(mock.calls.GetGpuFabricInfo, callInfo)
|
|
mock.lockGetGpuFabricInfo.Unlock()
|
|
return mock.GetGpuFabricInfoFunc()
|
|
}
|
|
|
|
// GetGpuFabricInfoCalls gets all the calls that were made to GetGpuFabricInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGpuFabricInfoCalls())
|
|
func (mock *Device) GetGpuFabricInfoCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetGpuFabricInfo.RLock()
|
|
calls = mock.calls.GetGpuFabricInfo
|
|
mock.lockGetGpuFabricInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGpuInstanceById calls GetGpuInstanceByIdFunc.
|
|
func (mock *Device) GetGpuInstanceById(n int) (nvml.GpuInstance, nvml.Return) {
|
|
if mock.GetGpuInstanceByIdFunc == nil {
|
|
panic("Device.GetGpuInstanceByIdFunc: method is nil but Device.GetGpuInstanceById was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockGetGpuInstanceById.Lock()
|
|
mock.calls.GetGpuInstanceById = append(mock.calls.GetGpuInstanceById, callInfo)
|
|
mock.lockGetGpuInstanceById.Unlock()
|
|
return mock.GetGpuInstanceByIdFunc(n)
|
|
}
|
|
|
|
// GetGpuInstanceByIdCalls gets all the calls that were made to GetGpuInstanceById.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGpuInstanceByIdCalls())
|
|
func (mock *Device) GetGpuInstanceByIdCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockGetGpuInstanceById.RLock()
|
|
calls = mock.calls.GetGpuInstanceById
|
|
mock.lockGetGpuInstanceById.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGpuInstanceId calls GetGpuInstanceIdFunc.
|
|
func (mock *Device) GetGpuInstanceId() (int, nvml.Return) {
|
|
if mock.GetGpuInstanceIdFunc == nil {
|
|
panic("Device.GetGpuInstanceIdFunc: method is nil but Device.GetGpuInstanceId was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetGpuInstanceId.Lock()
|
|
mock.calls.GetGpuInstanceId = append(mock.calls.GetGpuInstanceId, callInfo)
|
|
mock.lockGetGpuInstanceId.Unlock()
|
|
return mock.GetGpuInstanceIdFunc()
|
|
}
|
|
|
|
// GetGpuInstanceIdCalls gets all the calls that were made to GetGpuInstanceId.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGpuInstanceIdCalls())
|
|
func (mock *Device) GetGpuInstanceIdCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetGpuInstanceId.RLock()
|
|
calls = mock.calls.GetGpuInstanceId
|
|
mock.lockGetGpuInstanceId.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGpuInstancePossiblePlacements calls GetGpuInstancePossiblePlacementsFunc.
|
|
func (mock *Device) GetGpuInstancePossiblePlacements(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstancePlacement, nvml.Return) {
|
|
if mock.GetGpuInstancePossiblePlacementsFunc == nil {
|
|
panic("Device.GetGpuInstancePossiblePlacementsFunc: method is nil but Device.GetGpuInstancePossiblePlacements was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}{
|
|
GpuInstanceProfileInfo: gpuInstanceProfileInfo,
|
|
}
|
|
mock.lockGetGpuInstancePossiblePlacements.Lock()
|
|
mock.calls.GetGpuInstancePossiblePlacements = append(mock.calls.GetGpuInstancePossiblePlacements, callInfo)
|
|
mock.lockGetGpuInstancePossiblePlacements.Unlock()
|
|
return mock.GetGpuInstancePossiblePlacementsFunc(gpuInstanceProfileInfo)
|
|
}
|
|
|
|
// GetGpuInstancePossiblePlacementsCalls gets all the calls that were made to GetGpuInstancePossiblePlacements.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGpuInstancePossiblePlacementsCalls())
|
|
func (mock *Device) GetGpuInstancePossiblePlacementsCalls() []struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
} {
|
|
var calls []struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
mock.lockGetGpuInstancePossiblePlacements.RLock()
|
|
calls = mock.calls.GetGpuInstancePossiblePlacements
|
|
mock.lockGetGpuInstancePossiblePlacements.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGpuInstanceProfileInfo calls GetGpuInstanceProfileInfoFunc.
|
|
func (mock *Device) GetGpuInstanceProfileInfo(n int) (nvml.GpuInstanceProfileInfo, nvml.Return) {
|
|
if mock.GetGpuInstanceProfileInfoFunc == nil {
|
|
panic("Device.GetGpuInstanceProfileInfoFunc: method is nil but Device.GetGpuInstanceProfileInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockGetGpuInstanceProfileInfo.Lock()
|
|
mock.calls.GetGpuInstanceProfileInfo = append(mock.calls.GetGpuInstanceProfileInfo, callInfo)
|
|
mock.lockGetGpuInstanceProfileInfo.Unlock()
|
|
return mock.GetGpuInstanceProfileInfoFunc(n)
|
|
}
|
|
|
|
// GetGpuInstanceProfileInfoCalls gets all the calls that were made to GetGpuInstanceProfileInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGpuInstanceProfileInfoCalls())
|
|
func (mock *Device) GetGpuInstanceProfileInfoCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockGetGpuInstanceProfileInfo.RLock()
|
|
calls = mock.calls.GetGpuInstanceProfileInfo
|
|
mock.lockGetGpuInstanceProfileInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGpuInstanceProfileInfoV calls GetGpuInstanceProfileInfoVFunc.
|
|
func (mock *Device) GetGpuInstanceProfileInfoV(n int) nvml.GpuInstanceProfileInfoV {
|
|
if mock.GetGpuInstanceProfileInfoVFunc == nil {
|
|
panic("Device.GetGpuInstanceProfileInfoVFunc: method is nil but Device.GetGpuInstanceProfileInfoV was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockGetGpuInstanceProfileInfoV.Lock()
|
|
mock.calls.GetGpuInstanceProfileInfoV = append(mock.calls.GetGpuInstanceProfileInfoV, callInfo)
|
|
mock.lockGetGpuInstanceProfileInfoV.Unlock()
|
|
return mock.GetGpuInstanceProfileInfoVFunc(n)
|
|
}
|
|
|
|
// GetGpuInstanceProfileInfoVCalls gets all the calls that were made to GetGpuInstanceProfileInfoV.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGpuInstanceProfileInfoVCalls())
|
|
func (mock *Device) GetGpuInstanceProfileInfoVCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockGetGpuInstanceProfileInfoV.RLock()
|
|
calls = mock.calls.GetGpuInstanceProfileInfoV
|
|
mock.lockGetGpuInstanceProfileInfoV.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGpuInstanceRemainingCapacity calls GetGpuInstanceRemainingCapacityFunc.
|
|
func (mock *Device) GetGpuInstanceRemainingCapacity(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (int, nvml.Return) {
|
|
if mock.GetGpuInstanceRemainingCapacityFunc == nil {
|
|
panic("Device.GetGpuInstanceRemainingCapacityFunc: method is nil but Device.GetGpuInstanceRemainingCapacity was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}{
|
|
GpuInstanceProfileInfo: gpuInstanceProfileInfo,
|
|
}
|
|
mock.lockGetGpuInstanceRemainingCapacity.Lock()
|
|
mock.calls.GetGpuInstanceRemainingCapacity = append(mock.calls.GetGpuInstanceRemainingCapacity, callInfo)
|
|
mock.lockGetGpuInstanceRemainingCapacity.Unlock()
|
|
return mock.GetGpuInstanceRemainingCapacityFunc(gpuInstanceProfileInfo)
|
|
}
|
|
|
|
// GetGpuInstanceRemainingCapacityCalls gets all the calls that were made to GetGpuInstanceRemainingCapacity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGpuInstanceRemainingCapacityCalls())
|
|
func (mock *Device) GetGpuInstanceRemainingCapacityCalls() []struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
} {
|
|
var calls []struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
mock.lockGetGpuInstanceRemainingCapacity.RLock()
|
|
calls = mock.calls.GetGpuInstanceRemainingCapacity
|
|
mock.lockGetGpuInstanceRemainingCapacity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGpuInstances calls GetGpuInstancesFunc.
|
|
func (mock *Device) GetGpuInstances(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstance, nvml.Return) {
|
|
if mock.GetGpuInstancesFunc == nil {
|
|
panic("Device.GetGpuInstancesFunc: method is nil but Device.GetGpuInstances was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}{
|
|
GpuInstanceProfileInfo: gpuInstanceProfileInfo,
|
|
}
|
|
mock.lockGetGpuInstances.Lock()
|
|
mock.calls.GetGpuInstances = append(mock.calls.GetGpuInstances, callInfo)
|
|
mock.lockGetGpuInstances.Unlock()
|
|
return mock.GetGpuInstancesFunc(gpuInstanceProfileInfo)
|
|
}
|
|
|
|
// GetGpuInstancesCalls gets all the calls that were made to GetGpuInstances.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGpuInstancesCalls())
|
|
func (mock *Device) GetGpuInstancesCalls() []struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
} {
|
|
var calls []struct {
|
|
GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
|
|
}
|
|
mock.lockGetGpuInstances.RLock()
|
|
calls = mock.calls.GetGpuInstances
|
|
mock.lockGetGpuInstances.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGpuMaxPcieLinkGeneration calls GetGpuMaxPcieLinkGenerationFunc.
|
|
func (mock *Device) GetGpuMaxPcieLinkGeneration() (int, nvml.Return) {
|
|
if mock.GetGpuMaxPcieLinkGenerationFunc == nil {
|
|
panic("Device.GetGpuMaxPcieLinkGenerationFunc: method is nil but Device.GetGpuMaxPcieLinkGeneration was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetGpuMaxPcieLinkGeneration.Lock()
|
|
mock.calls.GetGpuMaxPcieLinkGeneration = append(mock.calls.GetGpuMaxPcieLinkGeneration, callInfo)
|
|
mock.lockGetGpuMaxPcieLinkGeneration.Unlock()
|
|
return mock.GetGpuMaxPcieLinkGenerationFunc()
|
|
}
|
|
|
|
// GetGpuMaxPcieLinkGenerationCalls gets all the calls that were made to GetGpuMaxPcieLinkGeneration.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGpuMaxPcieLinkGenerationCalls())
|
|
func (mock *Device) GetGpuMaxPcieLinkGenerationCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetGpuMaxPcieLinkGeneration.RLock()
|
|
calls = mock.calls.GetGpuMaxPcieLinkGeneration
|
|
mock.lockGetGpuMaxPcieLinkGeneration.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGpuOperationMode calls GetGpuOperationModeFunc.
|
|
func (mock *Device) GetGpuOperationMode() (nvml.GpuOperationMode, nvml.GpuOperationMode, nvml.Return) {
|
|
if mock.GetGpuOperationModeFunc == nil {
|
|
panic("Device.GetGpuOperationModeFunc: method is nil but Device.GetGpuOperationMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetGpuOperationMode.Lock()
|
|
mock.calls.GetGpuOperationMode = append(mock.calls.GetGpuOperationMode, callInfo)
|
|
mock.lockGetGpuOperationMode.Unlock()
|
|
return mock.GetGpuOperationModeFunc()
|
|
}
|
|
|
|
// GetGpuOperationModeCalls gets all the calls that were made to GetGpuOperationMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGpuOperationModeCalls())
|
|
func (mock *Device) GetGpuOperationModeCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetGpuOperationMode.RLock()
|
|
calls = mock.calls.GetGpuOperationMode
|
|
mock.lockGetGpuOperationMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGraphicsRunningProcesses calls GetGraphicsRunningProcessesFunc.
|
|
func (mock *Device) GetGraphicsRunningProcesses() ([]nvml.ProcessInfo, nvml.Return) {
|
|
if mock.GetGraphicsRunningProcessesFunc == nil {
|
|
panic("Device.GetGraphicsRunningProcessesFunc: method is nil but Device.GetGraphicsRunningProcesses was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetGraphicsRunningProcesses.Lock()
|
|
mock.calls.GetGraphicsRunningProcesses = append(mock.calls.GetGraphicsRunningProcesses, callInfo)
|
|
mock.lockGetGraphicsRunningProcesses.Unlock()
|
|
return mock.GetGraphicsRunningProcessesFunc()
|
|
}
|
|
|
|
// GetGraphicsRunningProcessesCalls gets all the calls that were made to GetGraphicsRunningProcesses.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGraphicsRunningProcessesCalls())
|
|
func (mock *Device) GetGraphicsRunningProcessesCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetGraphicsRunningProcesses.RLock()
|
|
calls = mock.calls.GetGraphicsRunningProcesses
|
|
mock.lockGetGraphicsRunningProcesses.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGridLicensableFeatures calls GetGridLicensableFeaturesFunc.
|
|
func (mock *Device) GetGridLicensableFeatures() (nvml.GridLicensableFeatures, nvml.Return) {
|
|
if mock.GetGridLicensableFeaturesFunc == nil {
|
|
panic("Device.GetGridLicensableFeaturesFunc: method is nil but Device.GetGridLicensableFeatures was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetGridLicensableFeatures.Lock()
|
|
mock.calls.GetGridLicensableFeatures = append(mock.calls.GetGridLicensableFeatures, callInfo)
|
|
mock.lockGetGridLicensableFeatures.Unlock()
|
|
return mock.GetGridLicensableFeaturesFunc()
|
|
}
|
|
|
|
// GetGridLicensableFeaturesCalls gets all the calls that were made to GetGridLicensableFeatures.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGridLicensableFeaturesCalls())
|
|
func (mock *Device) GetGridLicensableFeaturesCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetGridLicensableFeatures.RLock()
|
|
calls = mock.calls.GetGridLicensableFeatures
|
|
mock.lockGetGridLicensableFeatures.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGspFirmwareMode calls GetGspFirmwareModeFunc.
|
|
func (mock *Device) GetGspFirmwareMode() (bool, bool, nvml.Return) {
|
|
if mock.GetGspFirmwareModeFunc == nil {
|
|
panic("Device.GetGspFirmwareModeFunc: method is nil but Device.GetGspFirmwareMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetGspFirmwareMode.Lock()
|
|
mock.calls.GetGspFirmwareMode = append(mock.calls.GetGspFirmwareMode, callInfo)
|
|
mock.lockGetGspFirmwareMode.Unlock()
|
|
return mock.GetGspFirmwareModeFunc()
|
|
}
|
|
|
|
// GetGspFirmwareModeCalls gets all the calls that were made to GetGspFirmwareMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGspFirmwareModeCalls())
|
|
func (mock *Device) GetGspFirmwareModeCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetGspFirmwareMode.RLock()
|
|
calls = mock.calls.GetGspFirmwareMode
|
|
mock.lockGetGspFirmwareMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetGspFirmwareVersion calls GetGspFirmwareVersionFunc.
|
|
func (mock *Device) GetGspFirmwareVersion() (string, nvml.Return) {
|
|
if mock.GetGspFirmwareVersionFunc == nil {
|
|
panic("Device.GetGspFirmwareVersionFunc: method is nil but Device.GetGspFirmwareVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetGspFirmwareVersion.Lock()
|
|
mock.calls.GetGspFirmwareVersion = append(mock.calls.GetGspFirmwareVersion, callInfo)
|
|
mock.lockGetGspFirmwareVersion.Unlock()
|
|
return mock.GetGspFirmwareVersionFunc()
|
|
}
|
|
|
|
// GetGspFirmwareVersionCalls gets all the calls that were made to GetGspFirmwareVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetGspFirmwareVersionCalls())
|
|
func (mock *Device) GetGspFirmwareVersionCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetGspFirmwareVersion.RLock()
|
|
calls = mock.calls.GetGspFirmwareVersion
|
|
mock.lockGetGspFirmwareVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetHostVgpuMode calls GetHostVgpuModeFunc.
|
|
func (mock *Device) GetHostVgpuMode() (nvml.HostVgpuMode, nvml.Return) {
|
|
if mock.GetHostVgpuModeFunc == nil {
|
|
panic("Device.GetHostVgpuModeFunc: method is nil but Device.GetHostVgpuMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetHostVgpuMode.Lock()
|
|
mock.calls.GetHostVgpuMode = append(mock.calls.GetHostVgpuMode, callInfo)
|
|
mock.lockGetHostVgpuMode.Unlock()
|
|
return mock.GetHostVgpuModeFunc()
|
|
}
|
|
|
|
// GetHostVgpuModeCalls gets all the calls that were made to GetHostVgpuMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetHostVgpuModeCalls())
|
|
func (mock *Device) GetHostVgpuModeCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetHostVgpuMode.RLock()
|
|
calls = mock.calls.GetHostVgpuMode
|
|
mock.lockGetHostVgpuMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetIndex calls GetIndexFunc.
|
|
func (mock *Device) GetIndex() (int, nvml.Return) {
|
|
if mock.GetIndexFunc == nil {
|
|
panic("Device.GetIndexFunc: method is nil but Device.GetIndex was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetIndex.Lock()
|
|
mock.calls.GetIndex = append(mock.calls.GetIndex, callInfo)
|
|
mock.lockGetIndex.Unlock()
|
|
return mock.GetIndexFunc()
|
|
}
|
|
|
|
// GetIndexCalls gets all the calls that were made to GetIndex.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetIndexCalls())
|
|
func (mock *Device) GetIndexCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetIndex.RLock()
|
|
calls = mock.calls.GetIndex
|
|
mock.lockGetIndex.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetInforomConfigurationChecksum calls GetInforomConfigurationChecksumFunc.
|
|
func (mock *Device) GetInforomConfigurationChecksum() (uint32, nvml.Return) {
|
|
if mock.GetInforomConfigurationChecksumFunc == nil {
|
|
panic("Device.GetInforomConfigurationChecksumFunc: method is nil but Device.GetInforomConfigurationChecksum was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetInforomConfigurationChecksum.Lock()
|
|
mock.calls.GetInforomConfigurationChecksum = append(mock.calls.GetInforomConfigurationChecksum, callInfo)
|
|
mock.lockGetInforomConfigurationChecksum.Unlock()
|
|
return mock.GetInforomConfigurationChecksumFunc()
|
|
}
|
|
|
|
// GetInforomConfigurationChecksumCalls gets all the calls that were made to GetInforomConfigurationChecksum.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetInforomConfigurationChecksumCalls())
|
|
func (mock *Device) GetInforomConfigurationChecksumCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetInforomConfigurationChecksum.RLock()
|
|
calls = mock.calls.GetInforomConfigurationChecksum
|
|
mock.lockGetInforomConfigurationChecksum.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetInforomImageVersion calls GetInforomImageVersionFunc.
|
|
func (mock *Device) GetInforomImageVersion() (string, nvml.Return) {
|
|
if mock.GetInforomImageVersionFunc == nil {
|
|
panic("Device.GetInforomImageVersionFunc: method is nil but Device.GetInforomImageVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetInforomImageVersion.Lock()
|
|
mock.calls.GetInforomImageVersion = append(mock.calls.GetInforomImageVersion, callInfo)
|
|
mock.lockGetInforomImageVersion.Unlock()
|
|
return mock.GetInforomImageVersionFunc()
|
|
}
|
|
|
|
// GetInforomImageVersionCalls gets all the calls that were made to GetInforomImageVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetInforomImageVersionCalls())
|
|
func (mock *Device) GetInforomImageVersionCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetInforomImageVersion.RLock()
|
|
calls = mock.calls.GetInforomImageVersion
|
|
mock.lockGetInforomImageVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetInforomVersion calls GetInforomVersionFunc.
|
|
func (mock *Device) GetInforomVersion(inforomObject nvml.InforomObject) (string, nvml.Return) {
|
|
if mock.GetInforomVersionFunc == nil {
|
|
panic("Device.GetInforomVersionFunc: method is nil but Device.GetInforomVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
InforomObject nvml.InforomObject
|
|
}{
|
|
InforomObject: inforomObject,
|
|
}
|
|
mock.lockGetInforomVersion.Lock()
|
|
mock.calls.GetInforomVersion = append(mock.calls.GetInforomVersion, callInfo)
|
|
mock.lockGetInforomVersion.Unlock()
|
|
return mock.GetInforomVersionFunc(inforomObject)
|
|
}
|
|
|
|
// GetInforomVersionCalls gets all the calls that were made to GetInforomVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetInforomVersionCalls())
|
|
func (mock *Device) GetInforomVersionCalls() []struct {
|
|
InforomObject nvml.InforomObject
|
|
} {
|
|
var calls []struct {
|
|
InforomObject nvml.InforomObject
|
|
}
|
|
mock.lockGetInforomVersion.RLock()
|
|
calls = mock.calls.GetInforomVersion
|
|
mock.lockGetInforomVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetIrqNum calls GetIrqNumFunc.
|
|
func (mock *Device) GetIrqNum() (int, nvml.Return) {
|
|
if mock.GetIrqNumFunc == nil {
|
|
panic("Device.GetIrqNumFunc: method is nil but Device.GetIrqNum was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetIrqNum.Lock()
|
|
mock.calls.GetIrqNum = append(mock.calls.GetIrqNum, callInfo)
|
|
mock.lockGetIrqNum.Unlock()
|
|
return mock.GetIrqNumFunc()
|
|
}
|
|
|
|
// GetIrqNumCalls gets all the calls that were made to GetIrqNum.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetIrqNumCalls())
|
|
func (mock *Device) GetIrqNumCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetIrqNum.RLock()
|
|
calls = mock.calls.GetIrqNum
|
|
mock.lockGetIrqNum.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMPSComputeRunningProcesses calls GetMPSComputeRunningProcessesFunc.
|
|
func (mock *Device) GetMPSComputeRunningProcesses() ([]nvml.ProcessInfo, nvml.Return) {
|
|
if mock.GetMPSComputeRunningProcessesFunc == nil {
|
|
panic("Device.GetMPSComputeRunningProcessesFunc: method is nil but Device.GetMPSComputeRunningProcesses was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetMPSComputeRunningProcesses.Lock()
|
|
mock.calls.GetMPSComputeRunningProcesses = append(mock.calls.GetMPSComputeRunningProcesses, callInfo)
|
|
mock.lockGetMPSComputeRunningProcesses.Unlock()
|
|
return mock.GetMPSComputeRunningProcessesFunc()
|
|
}
|
|
|
|
// GetMPSComputeRunningProcessesCalls gets all the calls that were made to GetMPSComputeRunningProcesses.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMPSComputeRunningProcessesCalls())
|
|
func (mock *Device) GetMPSComputeRunningProcessesCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetMPSComputeRunningProcesses.RLock()
|
|
calls = mock.calls.GetMPSComputeRunningProcesses
|
|
mock.lockGetMPSComputeRunningProcesses.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMaxClockInfo calls GetMaxClockInfoFunc.
|
|
func (mock *Device) GetMaxClockInfo(clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
if mock.GetMaxClockInfoFunc == nil {
|
|
panic("Device.GetMaxClockInfoFunc: method is nil but Device.GetMaxClockInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
ClockType nvml.ClockType
|
|
}{
|
|
ClockType: clockType,
|
|
}
|
|
mock.lockGetMaxClockInfo.Lock()
|
|
mock.calls.GetMaxClockInfo = append(mock.calls.GetMaxClockInfo, callInfo)
|
|
mock.lockGetMaxClockInfo.Unlock()
|
|
return mock.GetMaxClockInfoFunc(clockType)
|
|
}
|
|
|
|
// GetMaxClockInfoCalls gets all the calls that were made to GetMaxClockInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMaxClockInfoCalls())
|
|
func (mock *Device) GetMaxClockInfoCalls() []struct {
|
|
ClockType nvml.ClockType
|
|
} {
|
|
var calls []struct {
|
|
ClockType nvml.ClockType
|
|
}
|
|
mock.lockGetMaxClockInfo.RLock()
|
|
calls = mock.calls.GetMaxClockInfo
|
|
mock.lockGetMaxClockInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMaxCustomerBoostClock calls GetMaxCustomerBoostClockFunc.
|
|
func (mock *Device) GetMaxCustomerBoostClock(clockType nvml.ClockType) (uint32, nvml.Return) {
|
|
if mock.GetMaxCustomerBoostClockFunc == nil {
|
|
panic("Device.GetMaxCustomerBoostClockFunc: method is nil but Device.GetMaxCustomerBoostClock was just called")
|
|
}
|
|
callInfo := struct {
|
|
ClockType nvml.ClockType
|
|
}{
|
|
ClockType: clockType,
|
|
}
|
|
mock.lockGetMaxCustomerBoostClock.Lock()
|
|
mock.calls.GetMaxCustomerBoostClock = append(mock.calls.GetMaxCustomerBoostClock, callInfo)
|
|
mock.lockGetMaxCustomerBoostClock.Unlock()
|
|
return mock.GetMaxCustomerBoostClockFunc(clockType)
|
|
}
|
|
|
|
// GetMaxCustomerBoostClockCalls gets all the calls that were made to GetMaxCustomerBoostClock.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMaxCustomerBoostClockCalls())
|
|
func (mock *Device) GetMaxCustomerBoostClockCalls() []struct {
|
|
ClockType nvml.ClockType
|
|
} {
|
|
var calls []struct {
|
|
ClockType nvml.ClockType
|
|
}
|
|
mock.lockGetMaxCustomerBoostClock.RLock()
|
|
calls = mock.calls.GetMaxCustomerBoostClock
|
|
mock.lockGetMaxCustomerBoostClock.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMaxMigDeviceCount calls GetMaxMigDeviceCountFunc.
|
|
func (mock *Device) GetMaxMigDeviceCount() (int, nvml.Return) {
|
|
if mock.GetMaxMigDeviceCountFunc == nil {
|
|
panic("Device.GetMaxMigDeviceCountFunc: method is nil but Device.GetMaxMigDeviceCount was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetMaxMigDeviceCount.Lock()
|
|
mock.calls.GetMaxMigDeviceCount = append(mock.calls.GetMaxMigDeviceCount, callInfo)
|
|
mock.lockGetMaxMigDeviceCount.Unlock()
|
|
return mock.GetMaxMigDeviceCountFunc()
|
|
}
|
|
|
|
// GetMaxMigDeviceCountCalls gets all the calls that were made to GetMaxMigDeviceCount.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMaxMigDeviceCountCalls())
|
|
func (mock *Device) GetMaxMigDeviceCountCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetMaxMigDeviceCount.RLock()
|
|
calls = mock.calls.GetMaxMigDeviceCount
|
|
mock.lockGetMaxMigDeviceCount.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMaxPcieLinkGeneration calls GetMaxPcieLinkGenerationFunc.
|
|
func (mock *Device) GetMaxPcieLinkGeneration() (int, nvml.Return) {
|
|
if mock.GetMaxPcieLinkGenerationFunc == nil {
|
|
panic("Device.GetMaxPcieLinkGenerationFunc: method is nil but Device.GetMaxPcieLinkGeneration was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetMaxPcieLinkGeneration.Lock()
|
|
mock.calls.GetMaxPcieLinkGeneration = append(mock.calls.GetMaxPcieLinkGeneration, callInfo)
|
|
mock.lockGetMaxPcieLinkGeneration.Unlock()
|
|
return mock.GetMaxPcieLinkGenerationFunc()
|
|
}
|
|
|
|
// GetMaxPcieLinkGenerationCalls gets all the calls that were made to GetMaxPcieLinkGeneration.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMaxPcieLinkGenerationCalls())
|
|
func (mock *Device) GetMaxPcieLinkGenerationCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetMaxPcieLinkGeneration.RLock()
|
|
calls = mock.calls.GetMaxPcieLinkGeneration
|
|
mock.lockGetMaxPcieLinkGeneration.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMaxPcieLinkWidth calls GetMaxPcieLinkWidthFunc.
|
|
func (mock *Device) GetMaxPcieLinkWidth() (int, nvml.Return) {
|
|
if mock.GetMaxPcieLinkWidthFunc == nil {
|
|
panic("Device.GetMaxPcieLinkWidthFunc: method is nil but Device.GetMaxPcieLinkWidth was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetMaxPcieLinkWidth.Lock()
|
|
mock.calls.GetMaxPcieLinkWidth = append(mock.calls.GetMaxPcieLinkWidth, callInfo)
|
|
mock.lockGetMaxPcieLinkWidth.Unlock()
|
|
return mock.GetMaxPcieLinkWidthFunc()
|
|
}
|
|
|
|
// GetMaxPcieLinkWidthCalls gets all the calls that were made to GetMaxPcieLinkWidth.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMaxPcieLinkWidthCalls())
|
|
func (mock *Device) GetMaxPcieLinkWidthCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetMaxPcieLinkWidth.RLock()
|
|
calls = mock.calls.GetMaxPcieLinkWidth
|
|
mock.lockGetMaxPcieLinkWidth.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMemClkMinMaxVfOffset calls GetMemClkMinMaxVfOffsetFunc.
|
|
func (mock *Device) GetMemClkMinMaxVfOffset() (int, int, nvml.Return) {
|
|
if mock.GetMemClkMinMaxVfOffsetFunc == nil {
|
|
panic("Device.GetMemClkMinMaxVfOffsetFunc: method is nil but Device.GetMemClkMinMaxVfOffset was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetMemClkMinMaxVfOffset.Lock()
|
|
mock.calls.GetMemClkMinMaxVfOffset = append(mock.calls.GetMemClkMinMaxVfOffset, callInfo)
|
|
mock.lockGetMemClkMinMaxVfOffset.Unlock()
|
|
return mock.GetMemClkMinMaxVfOffsetFunc()
|
|
}
|
|
|
|
// GetMemClkMinMaxVfOffsetCalls gets all the calls that were made to GetMemClkMinMaxVfOffset.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMemClkMinMaxVfOffsetCalls())
|
|
func (mock *Device) GetMemClkMinMaxVfOffsetCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetMemClkMinMaxVfOffset.RLock()
|
|
calls = mock.calls.GetMemClkMinMaxVfOffset
|
|
mock.lockGetMemClkMinMaxVfOffset.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMemClkVfOffset calls GetMemClkVfOffsetFunc.
|
|
func (mock *Device) GetMemClkVfOffset() (int, nvml.Return) {
|
|
if mock.GetMemClkVfOffsetFunc == nil {
|
|
panic("Device.GetMemClkVfOffsetFunc: method is nil but Device.GetMemClkVfOffset was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetMemClkVfOffset.Lock()
|
|
mock.calls.GetMemClkVfOffset = append(mock.calls.GetMemClkVfOffset, callInfo)
|
|
mock.lockGetMemClkVfOffset.Unlock()
|
|
return mock.GetMemClkVfOffsetFunc()
|
|
}
|
|
|
|
// GetMemClkVfOffsetCalls gets all the calls that were made to GetMemClkVfOffset.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMemClkVfOffsetCalls())
|
|
func (mock *Device) GetMemClkVfOffsetCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetMemClkVfOffset.RLock()
|
|
calls = mock.calls.GetMemClkVfOffset
|
|
mock.lockGetMemClkVfOffset.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMemoryAffinity calls GetMemoryAffinityFunc.
|
|
func (mock *Device) GetMemoryAffinity(n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return) {
|
|
if mock.GetMemoryAffinityFunc == nil {
|
|
panic("Device.GetMemoryAffinityFunc: method is nil but Device.GetMemoryAffinity was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
AffinityScope nvml.AffinityScope
|
|
}{
|
|
N: n,
|
|
AffinityScope: affinityScope,
|
|
}
|
|
mock.lockGetMemoryAffinity.Lock()
|
|
mock.calls.GetMemoryAffinity = append(mock.calls.GetMemoryAffinity, callInfo)
|
|
mock.lockGetMemoryAffinity.Unlock()
|
|
return mock.GetMemoryAffinityFunc(n, affinityScope)
|
|
}
|
|
|
|
// GetMemoryAffinityCalls gets all the calls that were made to GetMemoryAffinity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMemoryAffinityCalls())
|
|
func (mock *Device) GetMemoryAffinityCalls() []struct {
|
|
N int
|
|
AffinityScope nvml.AffinityScope
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
AffinityScope nvml.AffinityScope
|
|
}
|
|
mock.lockGetMemoryAffinity.RLock()
|
|
calls = mock.calls.GetMemoryAffinity
|
|
mock.lockGetMemoryAffinity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMemoryBusWidth calls GetMemoryBusWidthFunc.
|
|
func (mock *Device) GetMemoryBusWidth() (uint32, nvml.Return) {
|
|
if mock.GetMemoryBusWidthFunc == nil {
|
|
panic("Device.GetMemoryBusWidthFunc: method is nil but Device.GetMemoryBusWidth was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetMemoryBusWidth.Lock()
|
|
mock.calls.GetMemoryBusWidth = append(mock.calls.GetMemoryBusWidth, callInfo)
|
|
mock.lockGetMemoryBusWidth.Unlock()
|
|
return mock.GetMemoryBusWidthFunc()
|
|
}
|
|
|
|
// GetMemoryBusWidthCalls gets all the calls that were made to GetMemoryBusWidth.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMemoryBusWidthCalls())
|
|
func (mock *Device) GetMemoryBusWidthCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetMemoryBusWidth.RLock()
|
|
calls = mock.calls.GetMemoryBusWidth
|
|
mock.lockGetMemoryBusWidth.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMemoryErrorCounter calls GetMemoryErrorCounterFunc.
|
|
func (mock *Device) GetMemoryErrorCounter(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType, memoryLocation nvml.MemoryLocation) (uint64, nvml.Return) {
|
|
if mock.GetMemoryErrorCounterFunc == nil {
|
|
panic("Device.GetMemoryErrorCounterFunc: method is nil but Device.GetMemoryErrorCounter was just called")
|
|
}
|
|
callInfo := struct {
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
MemoryLocation nvml.MemoryLocation
|
|
}{
|
|
MemoryErrorType: memoryErrorType,
|
|
EccCounterType: eccCounterType,
|
|
MemoryLocation: memoryLocation,
|
|
}
|
|
mock.lockGetMemoryErrorCounter.Lock()
|
|
mock.calls.GetMemoryErrorCounter = append(mock.calls.GetMemoryErrorCounter, callInfo)
|
|
mock.lockGetMemoryErrorCounter.Unlock()
|
|
return mock.GetMemoryErrorCounterFunc(memoryErrorType, eccCounterType, memoryLocation)
|
|
}
|
|
|
|
// GetMemoryErrorCounterCalls gets all the calls that were made to GetMemoryErrorCounter.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMemoryErrorCounterCalls())
|
|
func (mock *Device) GetMemoryErrorCounterCalls() []struct {
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
MemoryLocation nvml.MemoryLocation
|
|
} {
|
|
var calls []struct {
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
MemoryLocation nvml.MemoryLocation
|
|
}
|
|
mock.lockGetMemoryErrorCounter.RLock()
|
|
calls = mock.calls.GetMemoryErrorCounter
|
|
mock.lockGetMemoryErrorCounter.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMemoryInfo calls GetMemoryInfoFunc.
|
|
func (mock *Device) GetMemoryInfo() (nvml.Memory, nvml.Return) {
|
|
if mock.GetMemoryInfoFunc == nil {
|
|
panic("Device.GetMemoryInfoFunc: method is nil but Device.GetMemoryInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetMemoryInfo.Lock()
|
|
mock.calls.GetMemoryInfo = append(mock.calls.GetMemoryInfo, callInfo)
|
|
mock.lockGetMemoryInfo.Unlock()
|
|
return mock.GetMemoryInfoFunc()
|
|
}
|
|
|
|
// GetMemoryInfoCalls gets all the calls that were made to GetMemoryInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMemoryInfoCalls())
|
|
func (mock *Device) GetMemoryInfoCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetMemoryInfo.RLock()
|
|
calls = mock.calls.GetMemoryInfo
|
|
mock.lockGetMemoryInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMemoryInfo_v2 calls GetMemoryInfo_v2Func.
|
|
func (mock *Device) GetMemoryInfo_v2() (nvml.Memory_v2, nvml.Return) {
|
|
if mock.GetMemoryInfo_v2Func == nil {
|
|
panic("Device.GetMemoryInfo_v2Func: method is nil but Device.GetMemoryInfo_v2 was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetMemoryInfo_v2.Lock()
|
|
mock.calls.GetMemoryInfo_v2 = append(mock.calls.GetMemoryInfo_v2, callInfo)
|
|
mock.lockGetMemoryInfo_v2.Unlock()
|
|
return mock.GetMemoryInfo_v2Func()
|
|
}
|
|
|
|
// GetMemoryInfo_v2Calls gets all the calls that were made to GetMemoryInfo_v2.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMemoryInfo_v2Calls())
|
|
func (mock *Device) GetMemoryInfo_v2Calls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetMemoryInfo_v2.RLock()
|
|
calls = mock.calls.GetMemoryInfo_v2
|
|
mock.lockGetMemoryInfo_v2.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMigDeviceHandleByIndex calls GetMigDeviceHandleByIndexFunc.
|
|
func (mock *Device) GetMigDeviceHandleByIndex(n int) (nvml.Device, nvml.Return) {
|
|
if mock.GetMigDeviceHandleByIndexFunc == nil {
|
|
panic("Device.GetMigDeviceHandleByIndexFunc: method is nil but Device.GetMigDeviceHandleByIndex was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockGetMigDeviceHandleByIndex.Lock()
|
|
mock.calls.GetMigDeviceHandleByIndex = append(mock.calls.GetMigDeviceHandleByIndex, callInfo)
|
|
mock.lockGetMigDeviceHandleByIndex.Unlock()
|
|
return mock.GetMigDeviceHandleByIndexFunc(n)
|
|
}
|
|
|
|
// GetMigDeviceHandleByIndexCalls gets all the calls that were made to GetMigDeviceHandleByIndex.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMigDeviceHandleByIndexCalls())
|
|
func (mock *Device) GetMigDeviceHandleByIndexCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockGetMigDeviceHandleByIndex.RLock()
|
|
calls = mock.calls.GetMigDeviceHandleByIndex
|
|
mock.lockGetMigDeviceHandleByIndex.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMigMode calls GetMigModeFunc.
|
|
func (mock *Device) GetMigMode() (int, int, nvml.Return) {
|
|
if mock.GetMigModeFunc == nil {
|
|
panic("Device.GetMigModeFunc: method is nil but Device.GetMigMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetMigMode.Lock()
|
|
mock.calls.GetMigMode = append(mock.calls.GetMigMode, callInfo)
|
|
mock.lockGetMigMode.Unlock()
|
|
return mock.GetMigModeFunc()
|
|
}
|
|
|
|
// GetMigModeCalls gets all the calls that were made to GetMigMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMigModeCalls())
|
|
func (mock *Device) GetMigModeCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetMigMode.RLock()
|
|
calls = mock.calls.GetMigMode
|
|
mock.lockGetMigMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMinMaxClockOfPState calls GetMinMaxClockOfPStateFunc.
|
|
func (mock *Device) GetMinMaxClockOfPState(clockType nvml.ClockType, pstates nvml.Pstates) (uint32, uint32, nvml.Return) {
|
|
if mock.GetMinMaxClockOfPStateFunc == nil {
|
|
panic("Device.GetMinMaxClockOfPStateFunc: method is nil but Device.GetMinMaxClockOfPState was just called")
|
|
}
|
|
callInfo := struct {
|
|
ClockType nvml.ClockType
|
|
Pstates nvml.Pstates
|
|
}{
|
|
ClockType: clockType,
|
|
Pstates: pstates,
|
|
}
|
|
mock.lockGetMinMaxClockOfPState.Lock()
|
|
mock.calls.GetMinMaxClockOfPState = append(mock.calls.GetMinMaxClockOfPState, callInfo)
|
|
mock.lockGetMinMaxClockOfPState.Unlock()
|
|
return mock.GetMinMaxClockOfPStateFunc(clockType, pstates)
|
|
}
|
|
|
|
// GetMinMaxClockOfPStateCalls gets all the calls that were made to GetMinMaxClockOfPState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMinMaxClockOfPStateCalls())
|
|
func (mock *Device) GetMinMaxClockOfPStateCalls() []struct {
|
|
ClockType nvml.ClockType
|
|
Pstates nvml.Pstates
|
|
} {
|
|
var calls []struct {
|
|
ClockType nvml.ClockType
|
|
Pstates nvml.Pstates
|
|
}
|
|
mock.lockGetMinMaxClockOfPState.RLock()
|
|
calls = mock.calls.GetMinMaxClockOfPState
|
|
mock.lockGetMinMaxClockOfPState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMinMaxFanSpeed calls GetMinMaxFanSpeedFunc.
|
|
func (mock *Device) GetMinMaxFanSpeed() (int, int, nvml.Return) {
|
|
if mock.GetMinMaxFanSpeedFunc == nil {
|
|
panic("Device.GetMinMaxFanSpeedFunc: method is nil but Device.GetMinMaxFanSpeed was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetMinMaxFanSpeed.Lock()
|
|
mock.calls.GetMinMaxFanSpeed = append(mock.calls.GetMinMaxFanSpeed, callInfo)
|
|
mock.lockGetMinMaxFanSpeed.Unlock()
|
|
return mock.GetMinMaxFanSpeedFunc()
|
|
}
|
|
|
|
// GetMinMaxFanSpeedCalls gets all the calls that were made to GetMinMaxFanSpeed.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMinMaxFanSpeedCalls())
|
|
func (mock *Device) GetMinMaxFanSpeedCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetMinMaxFanSpeed.RLock()
|
|
calls = mock.calls.GetMinMaxFanSpeed
|
|
mock.lockGetMinMaxFanSpeed.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMinorNumber calls GetMinorNumberFunc.
|
|
func (mock *Device) GetMinorNumber() (int, nvml.Return) {
|
|
if mock.GetMinorNumberFunc == nil {
|
|
panic("Device.GetMinorNumberFunc: method is nil but Device.GetMinorNumber was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetMinorNumber.Lock()
|
|
mock.calls.GetMinorNumber = append(mock.calls.GetMinorNumber, callInfo)
|
|
mock.lockGetMinorNumber.Unlock()
|
|
return mock.GetMinorNumberFunc()
|
|
}
|
|
|
|
// GetMinorNumberCalls gets all the calls that were made to GetMinorNumber.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMinorNumberCalls())
|
|
func (mock *Device) GetMinorNumberCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetMinorNumber.RLock()
|
|
calls = mock.calls.GetMinorNumber
|
|
mock.lockGetMinorNumber.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetMultiGpuBoard calls GetMultiGpuBoardFunc.
|
|
func (mock *Device) GetMultiGpuBoard() (int, nvml.Return) {
|
|
if mock.GetMultiGpuBoardFunc == nil {
|
|
panic("Device.GetMultiGpuBoardFunc: method is nil but Device.GetMultiGpuBoard was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetMultiGpuBoard.Lock()
|
|
mock.calls.GetMultiGpuBoard = append(mock.calls.GetMultiGpuBoard, callInfo)
|
|
mock.lockGetMultiGpuBoard.Unlock()
|
|
return mock.GetMultiGpuBoardFunc()
|
|
}
|
|
|
|
// GetMultiGpuBoardCalls gets all the calls that were made to GetMultiGpuBoard.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetMultiGpuBoardCalls())
|
|
func (mock *Device) GetMultiGpuBoardCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetMultiGpuBoard.RLock()
|
|
calls = mock.calls.GetMultiGpuBoard
|
|
mock.lockGetMultiGpuBoard.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetName calls GetNameFunc.
|
|
func (mock *Device) GetName() (string, nvml.Return) {
|
|
if mock.GetNameFunc == nil {
|
|
panic("Device.GetNameFunc: method is nil but Device.GetName was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetName.Lock()
|
|
mock.calls.GetName = append(mock.calls.GetName, callInfo)
|
|
mock.lockGetName.Unlock()
|
|
return mock.GetNameFunc()
|
|
}
|
|
|
|
// GetNameCalls gets all the calls that were made to GetName.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetNameCalls())
|
|
func (mock *Device) GetNameCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetName.RLock()
|
|
calls = mock.calls.GetName
|
|
mock.lockGetName.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetNumFans calls GetNumFansFunc.
|
|
func (mock *Device) GetNumFans() (int, nvml.Return) {
|
|
if mock.GetNumFansFunc == nil {
|
|
panic("Device.GetNumFansFunc: method is nil but Device.GetNumFans was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetNumFans.Lock()
|
|
mock.calls.GetNumFans = append(mock.calls.GetNumFans, callInfo)
|
|
mock.lockGetNumFans.Unlock()
|
|
return mock.GetNumFansFunc()
|
|
}
|
|
|
|
// GetNumFansCalls gets all the calls that were made to GetNumFans.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetNumFansCalls())
|
|
func (mock *Device) GetNumFansCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetNumFans.RLock()
|
|
calls = mock.calls.GetNumFans
|
|
mock.lockGetNumFans.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetNumGpuCores calls GetNumGpuCoresFunc.
|
|
func (mock *Device) GetNumGpuCores() (int, nvml.Return) {
|
|
if mock.GetNumGpuCoresFunc == nil {
|
|
panic("Device.GetNumGpuCoresFunc: method is nil but Device.GetNumGpuCores was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetNumGpuCores.Lock()
|
|
mock.calls.GetNumGpuCores = append(mock.calls.GetNumGpuCores, callInfo)
|
|
mock.lockGetNumGpuCores.Unlock()
|
|
return mock.GetNumGpuCoresFunc()
|
|
}
|
|
|
|
// GetNumGpuCoresCalls gets all the calls that were made to GetNumGpuCores.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetNumGpuCoresCalls())
|
|
func (mock *Device) GetNumGpuCoresCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetNumGpuCores.RLock()
|
|
calls = mock.calls.GetNumGpuCores
|
|
mock.lockGetNumGpuCores.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetNvLinkCapability calls GetNvLinkCapabilityFunc.
|
|
func (mock *Device) GetNvLinkCapability(n int, nvLinkCapability nvml.NvLinkCapability) (uint32, nvml.Return) {
|
|
if mock.GetNvLinkCapabilityFunc == nil {
|
|
panic("Device.GetNvLinkCapabilityFunc: method is nil but Device.GetNvLinkCapability was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
NvLinkCapability nvml.NvLinkCapability
|
|
}{
|
|
N: n,
|
|
NvLinkCapability: nvLinkCapability,
|
|
}
|
|
mock.lockGetNvLinkCapability.Lock()
|
|
mock.calls.GetNvLinkCapability = append(mock.calls.GetNvLinkCapability, callInfo)
|
|
mock.lockGetNvLinkCapability.Unlock()
|
|
return mock.GetNvLinkCapabilityFunc(n, nvLinkCapability)
|
|
}
|
|
|
|
// GetNvLinkCapabilityCalls gets all the calls that were made to GetNvLinkCapability.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetNvLinkCapabilityCalls())
|
|
func (mock *Device) GetNvLinkCapabilityCalls() []struct {
|
|
N int
|
|
NvLinkCapability nvml.NvLinkCapability
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
NvLinkCapability nvml.NvLinkCapability
|
|
}
|
|
mock.lockGetNvLinkCapability.RLock()
|
|
calls = mock.calls.GetNvLinkCapability
|
|
mock.lockGetNvLinkCapability.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetNvLinkErrorCounter calls GetNvLinkErrorCounterFunc.
|
|
func (mock *Device) GetNvLinkErrorCounter(n int, nvLinkErrorCounter nvml.NvLinkErrorCounter) (uint64, nvml.Return) {
|
|
if mock.GetNvLinkErrorCounterFunc == nil {
|
|
panic("Device.GetNvLinkErrorCounterFunc: method is nil but Device.GetNvLinkErrorCounter was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
NvLinkErrorCounter nvml.NvLinkErrorCounter
|
|
}{
|
|
N: n,
|
|
NvLinkErrorCounter: nvLinkErrorCounter,
|
|
}
|
|
mock.lockGetNvLinkErrorCounter.Lock()
|
|
mock.calls.GetNvLinkErrorCounter = append(mock.calls.GetNvLinkErrorCounter, callInfo)
|
|
mock.lockGetNvLinkErrorCounter.Unlock()
|
|
return mock.GetNvLinkErrorCounterFunc(n, nvLinkErrorCounter)
|
|
}
|
|
|
|
// GetNvLinkErrorCounterCalls gets all the calls that were made to GetNvLinkErrorCounter.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetNvLinkErrorCounterCalls())
|
|
func (mock *Device) GetNvLinkErrorCounterCalls() []struct {
|
|
N int
|
|
NvLinkErrorCounter nvml.NvLinkErrorCounter
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
NvLinkErrorCounter nvml.NvLinkErrorCounter
|
|
}
|
|
mock.lockGetNvLinkErrorCounter.RLock()
|
|
calls = mock.calls.GetNvLinkErrorCounter
|
|
mock.lockGetNvLinkErrorCounter.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetNvLinkRemoteDeviceType calls GetNvLinkRemoteDeviceTypeFunc.
|
|
func (mock *Device) GetNvLinkRemoteDeviceType(n int) (nvml.IntNvLinkDeviceType, nvml.Return) {
|
|
if mock.GetNvLinkRemoteDeviceTypeFunc == nil {
|
|
panic("Device.GetNvLinkRemoteDeviceTypeFunc: method is nil but Device.GetNvLinkRemoteDeviceType was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockGetNvLinkRemoteDeviceType.Lock()
|
|
mock.calls.GetNvLinkRemoteDeviceType = append(mock.calls.GetNvLinkRemoteDeviceType, callInfo)
|
|
mock.lockGetNvLinkRemoteDeviceType.Unlock()
|
|
return mock.GetNvLinkRemoteDeviceTypeFunc(n)
|
|
}
|
|
|
|
// GetNvLinkRemoteDeviceTypeCalls gets all the calls that were made to GetNvLinkRemoteDeviceType.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetNvLinkRemoteDeviceTypeCalls())
|
|
func (mock *Device) GetNvLinkRemoteDeviceTypeCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockGetNvLinkRemoteDeviceType.RLock()
|
|
calls = mock.calls.GetNvLinkRemoteDeviceType
|
|
mock.lockGetNvLinkRemoteDeviceType.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetNvLinkRemotePciInfo calls GetNvLinkRemotePciInfoFunc.
|
|
func (mock *Device) GetNvLinkRemotePciInfo(n int) (nvml.PciInfo, nvml.Return) {
|
|
if mock.GetNvLinkRemotePciInfoFunc == nil {
|
|
panic("Device.GetNvLinkRemotePciInfoFunc: method is nil but Device.GetNvLinkRemotePciInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockGetNvLinkRemotePciInfo.Lock()
|
|
mock.calls.GetNvLinkRemotePciInfo = append(mock.calls.GetNvLinkRemotePciInfo, callInfo)
|
|
mock.lockGetNvLinkRemotePciInfo.Unlock()
|
|
return mock.GetNvLinkRemotePciInfoFunc(n)
|
|
}
|
|
|
|
// GetNvLinkRemotePciInfoCalls gets all the calls that were made to GetNvLinkRemotePciInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetNvLinkRemotePciInfoCalls())
|
|
func (mock *Device) GetNvLinkRemotePciInfoCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockGetNvLinkRemotePciInfo.RLock()
|
|
calls = mock.calls.GetNvLinkRemotePciInfo
|
|
mock.lockGetNvLinkRemotePciInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetNvLinkState calls GetNvLinkStateFunc.
|
|
func (mock *Device) GetNvLinkState(n int) (nvml.EnableState, nvml.Return) {
|
|
if mock.GetNvLinkStateFunc == nil {
|
|
panic("Device.GetNvLinkStateFunc: method is nil but Device.GetNvLinkState was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockGetNvLinkState.Lock()
|
|
mock.calls.GetNvLinkState = append(mock.calls.GetNvLinkState, callInfo)
|
|
mock.lockGetNvLinkState.Unlock()
|
|
return mock.GetNvLinkStateFunc(n)
|
|
}
|
|
|
|
// GetNvLinkStateCalls gets all the calls that were made to GetNvLinkState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetNvLinkStateCalls())
|
|
func (mock *Device) GetNvLinkStateCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockGetNvLinkState.RLock()
|
|
calls = mock.calls.GetNvLinkState
|
|
mock.lockGetNvLinkState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetNvLinkUtilizationControl calls GetNvLinkUtilizationControlFunc.
|
|
func (mock *Device) GetNvLinkUtilizationControl(n1 int, n2 int) (nvml.NvLinkUtilizationControl, nvml.Return) {
|
|
if mock.GetNvLinkUtilizationControlFunc == nil {
|
|
panic("Device.GetNvLinkUtilizationControlFunc: method is nil but Device.GetNvLinkUtilizationControl was just called")
|
|
}
|
|
callInfo := struct {
|
|
N1 int
|
|
N2 int
|
|
}{
|
|
N1: n1,
|
|
N2: n2,
|
|
}
|
|
mock.lockGetNvLinkUtilizationControl.Lock()
|
|
mock.calls.GetNvLinkUtilizationControl = append(mock.calls.GetNvLinkUtilizationControl, callInfo)
|
|
mock.lockGetNvLinkUtilizationControl.Unlock()
|
|
return mock.GetNvLinkUtilizationControlFunc(n1, n2)
|
|
}
|
|
|
|
// GetNvLinkUtilizationControlCalls gets all the calls that were made to GetNvLinkUtilizationControl.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetNvLinkUtilizationControlCalls())
|
|
func (mock *Device) GetNvLinkUtilizationControlCalls() []struct {
|
|
N1 int
|
|
N2 int
|
|
} {
|
|
var calls []struct {
|
|
N1 int
|
|
N2 int
|
|
}
|
|
mock.lockGetNvLinkUtilizationControl.RLock()
|
|
calls = mock.calls.GetNvLinkUtilizationControl
|
|
mock.lockGetNvLinkUtilizationControl.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetNvLinkUtilizationCounter calls GetNvLinkUtilizationCounterFunc.
|
|
func (mock *Device) GetNvLinkUtilizationCounter(n1 int, n2 int) (uint64, uint64, nvml.Return) {
|
|
if mock.GetNvLinkUtilizationCounterFunc == nil {
|
|
panic("Device.GetNvLinkUtilizationCounterFunc: method is nil but Device.GetNvLinkUtilizationCounter was just called")
|
|
}
|
|
callInfo := struct {
|
|
N1 int
|
|
N2 int
|
|
}{
|
|
N1: n1,
|
|
N2: n2,
|
|
}
|
|
mock.lockGetNvLinkUtilizationCounter.Lock()
|
|
mock.calls.GetNvLinkUtilizationCounter = append(mock.calls.GetNvLinkUtilizationCounter, callInfo)
|
|
mock.lockGetNvLinkUtilizationCounter.Unlock()
|
|
return mock.GetNvLinkUtilizationCounterFunc(n1, n2)
|
|
}
|
|
|
|
// GetNvLinkUtilizationCounterCalls gets all the calls that were made to GetNvLinkUtilizationCounter.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetNvLinkUtilizationCounterCalls())
|
|
func (mock *Device) GetNvLinkUtilizationCounterCalls() []struct {
|
|
N1 int
|
|
N2 int
|
|
} {
|
|
var calls []struct {
|
|
N1 int
|
|
N2 int
|
|
}
|
|
mock.lockGetNvLinkUtilizationCounter.RLock()
|
|
calls = mock.calls.GetNvLinkUtilizationCounter
|
|
mock.lockGetNvLinkUtilizationCounter.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetNvLinkVersion calls GetNvLinkVersionFunc.
|
|
func (mock *Device) GetNvLinkVersion(n int) (uint32, nvml.Return) {
|
|
if mock.GetNvLinkVersionFunc == nil {
|
|
panic("Device.GetNvLinkVersionFunc: method is nil but Device.GetNvLinkVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockGetNvLinkVersion.Lock()
|
|
mock.calls.GetNvLinkVersion = append(mock.calls.GetNvLinkVersion, callInfo)
|
|
mock.lockGetNvLinkVersion.Unlock()
|
|
return mock.GetNvLinkVersionFunc(n)
|
|
}
|
|
|
|
// GetNvLinkVersionCalls gets all the calls that were made to GetNvLinkVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetNvLinkVersionCalls())
|
|
func (mock *Device) GetNvLinkVersionCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockGetNvLinkVersion.RLock()
|
|
calls = mock.calls.GetNvLinkVersion
|
|
mock.lockGetNvLinkVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetP2PStatus calls GetP2PStatusFunc.
|
|
func (mock *Device) GetP2PStatus(device nvml.Device, gpuP2PCapsIndex nvml.GpuP2PCapsIndex) (nvml.GpuP2PStatus, nvml.Return) {
|
|
if mock.GetP2PStatusFunc == nil {
|
|
panic("Device.GetP2PStatusFunc: method is nil but Device.GetP2PStatus was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
GpuP2PCapsIndex nvml.GpuP2PCapsIndex
|
|
}{
|
|
Device: device,
|
|
GpuP2PCapsIndex: gpuP2PCapsIndex,
|
|
}
|
|
mock.lockGetP2PStatus.Lock()
|
|
mock.calls.GetP2PStatus = append(mock.calls.GetP2PStatus, callInfo)
|
|
mock.lockGetP2PStatus.Unlock()
|
|
return mock.GetP2PStatusFunc(device, gpuP2PCapsIndex)
|
|
}
|
|
|
|
// GetP2PStatusCalls gets all the calls that were made to GetP2PStatus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetP2PStatusCalls())
|
|
func (mock *Device) GetP2PStatusCalls() []struct {
|
|
Device nvml.Device
|
|
GpuP2PCapsIndex nvml.GpuP2PCapsIndex
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
GpuP2PCapsIndex nvml.GpuP2PCapsIndex
|
|
}
|
|
mock.lockGetP2PStatus.RLock()
|
|
calls = mock.calls.GetP2PStatus
|
|
mock.lockGetP2PStatus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPciInfo calls GetPciInfoFunc.
|
|
func (mock *Device) GetPciInfo() (nvml.PciInfo, nvml.Return) {
|
|
if mock.GetPciInfoFunc == nil {
|
|
panic("Device.GetPciInfoFunc: method is nil but Device.GetPciInfo was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetPciInfo.Lock()
|
|
mock.calls.GetPciInfo = append(mock.calls.GetPciInfo, callInfo)
|
|
mock.lockGetPciInfo.Unlock()
|
|
return mock.GetPciInfoFunc()
|
|
}
|
|
|
|
// GetPciInfoCalls gets all the calls that were made to GetPciInfo.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPciInfoCalls())
|
|
func (mock *Device) GetPciInfoCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetPciInfo.RLock()
|
|
calls = mock.calls.GetPciInfo
|
|
mock.lockGetPciInfo.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPcieLinkMaxSpeed calls GetPcieLinkMaxSpeedFunc.
|
|
func (mock *Device) GetPcieLinkMaxSpeed() (uint32, nvml.Return) {
|
|
if mock.GetPcieLinkMaxSpeedFunc == nil {
|
|
panic("Device.GetPcieLinkMaxSpeedFunc: method is nil but Device.GetPcieLinkMaxSpeed was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetPcieLinkMaxSpeed.Lock()
|
|
mock.calls.GetPcieLinkMaxSpeed = append(mock.calls.GetPcieLinkMaxSpeed, callInfo)
|
|
mock.lockGetPcieLinkMaxSpeed.Unlock()
|
|
return mock.GetPcieLinkMaxSpeedFunc()
|
|
}
|
|
|
|
// GetPcieLinkMaxSpeedCalls gets all the calls that were made to GetPcieLinkMaxSpeed.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPcieLinkMaxSpeedCalls())
|
|
func (mock *Device) GetPcieLinkMaxSpeedCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetPcieLinkMaxSpeed.RLock()
|
|
calls = mock.calls.GetPcieLinkMaxSpeed
|
|
mock.lockGetPcieLinkMaxSpeed.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPcieReplayCounter calls GetPcieReplayCounterFunc.
|
|
func (mock *Device) GetPcieReplayCounter() (int, nvml.Return) {
|
|
if mock.GetPcieReplayCounterFunc == nil {
|
|
panic("Device.GetPcieReplayCounterFunc: method is nil but Device.GetPcieReplayCounter was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetPcieReplayCounter.Lock()
|
|
mock.calls.GetPcieReplayCounter = append(mock.calls.GetPcieReplayCounter, callInfo)
|
|
mock.lockGetPcieReplayCounter.Unlock()
|
|
return mock.GetPcieReplayCounterFunc()
|
|
}
|
|
|
|
// GetPcieReplayCounterCalls gets all the calls that were made to GetPcieReplayCounter.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPcieReplayCounterCalls())
|
|
func (mock *Device) GetPcieReplayCounterCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetPcieReplayCounter.RLock()
|
|
calls = mock.calls.GetPcieReplayCounter
|
|
mock.lockGetPcieReplayCounter.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPcieSpeed calls GetPcieSpeedFunc.
|
|
func (mock *Device) GetPcieSpeed() (int, nvml.Return) {
|
|
if mock.GetPcieSpeedFunc == nil {
|
|
panic("Device.GetPcieSpeedFunc: method is nil but Device.GetPcieSpeed was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetPcieSpeed.Lock()
|
|
mock.calls.GetPcieSpeed = append(mock.calls.GetPcieSpeed, callInfo)
|
|
mock.lockGetPcieSpeed.Unlock()
|
|
return mock.GetPcieSpeedFunc()
|
|
}
|
|
|
|
// GetPcieSpeedCalls gets all the calls that were made to GetPcieSpeed.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPcieSpeedCalls())
|
|
func (mock *Device) GetPcieSpeedCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetPcieSpeed.RLock()
|
|
calls = mock.calls.GetPcieSpeed
|
|
mock.lockGetPcieSpeed.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPcieThroughput calls GetPcieThroughputFunc.
|
|
func (mock *Device) GetPcieThroughput(pcieUtilCounter nvml.PcieUtilCounter) (uint32, nvml.Return) {
|
|
if mock.GetPcieThroughputFunc == nil {
|
|
panic("Device.GetPcieThroughputFunc: method is nil but Device.GetPcieThroughput was just called")
|
|
}
|
|
callInfo := struct {
|
|
PcieUtilCounter nvml.PcieUtilCounter
|
|
}{
|
|
PcieUtilCounter: pcieUtilCounter,
|
|
}
|
|
mock.lockGetPcieThroughput.Lock()
|
|
mock.calls.GetPcieThroughput = append(mock.calls.GetPcieThroughput, callInfo)
|
|
mock.lockGetPcieThroughput.Unlock()
|
|
return mock.GetPcieThroughputFunc(pcieUtilCounter)
|
|
}
|
|
|
|
// GetPcieThroughputCalls gets all the calls that were made to GetPcieThroughput.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPcieThroughputCalls())
|
|
func (mock *Device) GetPcieThroughputCalls() []struct {
|
|
PcieUtilCounter nvml.PcieUtilCounter
|
|
} {
|
|
var calls []struct {
|
|
PcieUtilCounter nvml.PcieUtilCounter
|
|
}
|
|
mock.lockGetPcieThroughput.RLock()
|
|
calls = mock.calls.GetPcieThroughput
|
|
mock.lockGetPcieThroughput.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPerformanceState calls GetPerformanceStateFunc.
|
|
func (mock *Device) GetPerformanceState() (nvml.Pstates, nvml.Return) {
|
|
if mock.GetPerformanceStateFunc == nil {
|
|
panic("Device.GetPerformanceStateFunc: method is nil but Device.GetPerformanceState was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetPerformanceState.Lock()
|
|
mock.calls.GetPerformanceState = append(mock.calls.GetPerformanceState, callInfo)
|
|
mock.lockGetPerformanceState.Unlock()
|
|
return mock.GetPerformanceStateFunc()
|
|
}
|
|
|
|
// GetPerformanceStateCalls gets all the calls that were made to GetPerformanceState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPerformanceStateCalls())
|
|
func (mock *Device) GetPerformanceStateCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetPerformanceState.RLock()
|
|
calls = mock.calls.GetPerformanceState
|
|
mock.lockGetPerformanceState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPersistenceMode calls GetPersistenceModeFunc.
|
|
func (mock *Device) GetPersistenceMode() (nvml.EnableState, nvml.Return) {
|
|
if mock.GetPersistenceModeFunc == nil {
|
|
panic("Device.GetPersistenceModeFunc: method is nil but Device.GetPersistenceMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetPersistenceMode.Lock()
|
|
mock.calls.GetPersistenceMode = append(mock.calls.GetPersistenceMode, callInfo)
|
|
mock.lockGetPersistenceMode.Unlock()
|
|
return mock.GetPersistenceModeFunc()
|
|
}
|
|
|
|
// GetPersistenceModeCalls gets all the calls that were made to GetPersistenceMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPersistenceModeCalls())
|
|
func (mock *Device) GetPersistenceModeCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetPersistenceMode.RLock()
|
|
calls = mock.calls.GetPersistenceMode
|
|
mock.lockGetPersistenceMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPgpuMetadataString calls GetPgpuMetadataStringFunc.
|
|
func (mock *Device) GetPgpuMetadataString() (string, nvml.Return) {
|
|
if mock.GetPgpuMetadataStringFunc == nil {
|
|
panic("Device.GetPgpuMetadataStringFunc: method is nil but Device.GetPgpuMetadataString was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetPgpuMetadataString.Lock()
|
|
mock.calls.GetPgpuMetadataString = append(mock.calls.GetPgpuMetadataString, callInfo)
|
|
mock.lockGetPgpuMetadataString.Unlock()
|
|
return mock.GetPgpuMetadataStringFunc()
|
|
}
|
|
|
|
// GetPgpuMetadataStringCalls gets all the calls that were made to GetPgpuMetadataString.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPgpuMetadataStringCalls())
|
|
func (mock *Device) GetPgpuMetadataStringCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetPgpuMetadataString.RLock()
|
|
calls = mock.calls.GetPgpuMetadataString
|
|
mock.lockGetPgpuMetadataString.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPowerManagementDefaultLimit calls GetPowerManagementDefaultLimitFunc.
|
|
func (mock *Device) GetPowerManagementDefaultLimit() (uint32, nvml.Return) {
|
|
if mock.GetPowerManagementDefaultLimitFunc == nil {
|
|
panic("Device.GetPowerManagementDefaultLimitFunc: method is nil but Device.GetPowerManagementDefaultLimit was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetPowerManagementDefaultLimit.Lock()
|
|
mock.calls.GetPowerManagementDefaultLimit = append(mock.calls.GetPowerManagementDefaultLimit, callInfo)
|
|
mock.lockGetPowerManagementDefaultLimit.Unlock()
|
|
return mock.GetPowerManagementDefaultLimitFunc()
|
|
}
|
|
|
|
// GetPowerManagementDefaultLimitCalls gets all the calls that were made to GetPowerManagementDefaultLimit.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPowerManagementDefaultLimitCalls())
|
|
func (mock *Device) GetPowerManagementDefaultLimitCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetPowerManagementDefaultLimit.RLock()
|
|
calls = mock.calls.GetPowerManagementDefaultLimit
|
|
mock.lockGetPowerManagementDefaultLimit.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPowerManagementLimit calls GetPowerManagementLimitFunc.
|
|
func (mock *Device) GetPowerManagementLimit() (uint32, nvml.Return) {
|
|
if mock.GetPowerManagementLimitFunc == nil {
|
|
panic("Device.GetPowerManagementLimitFunc: method is nil but Device.GetPowerManagementLimit was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetPowerManagementLimit.Lock()
|
|
mock.calls.GetPowerManagementLimit = append(mock.calls.GetPowerManagementLimit, callInfo)
|
|
mock.lockGetPowerManagementLimit.Unlock()
|
|
return mock.GetPowerManagementLimitFunc()
|
|
}
|
|
|
|
// GetPowerManagementLimitCalls gets all the calls that were made to GetPowerManagementLimit.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPowerManagementLimitCalls())
|
|
func (mock *Device) GetPowerManagementLimitCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetPowerManagementLimit.RLock()
|
|
calls = mock.calls.GetPowerManagementLimit
|
|
mock.lockGetPowerManagementLimit.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPowerManagementLimitConstraints calls GetPowerManagementLimitConstraintsFunc.
|
|
func (mock *Device) GetPowerManagementLimitConstraints() (uint32, uint32, nvml.Return) {
|
|
if mock.GetPowerManagementLimitConstraintsFunc == nil {
|
|
panic("Device.GetPowerManagementLimitConstraintsFunc: method is nil but Device.GetPowerManagementLimitConstraints was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetPowerManagementLimitConstraints.Lock()
|
|
mock.calls.GetPowerManagementLimitConstraints = append(mock.calls.GetPowerManagementLimitConstraints, callInfo)
|
|
mock.lockGetPowerManagementLimitConstraints.Unlock()
|
|
return mock.GetPowerManagementLimitConstraintsFunc()
|
|
}
|
|
|
|
// GetPowerManagementLimitConstraintsCalls gets all the calls that were made to GetPowerManagementLimitConstraints.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPowerManagementLimitConstraintsCalls())
|
|
func (mock *Device) GetPowerManagementLimitConstraintsCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetPowerManagementLimitConstraints.RLock()
|
|
calls = mock.calls.GetPowerManagementLimitConstraints
|
|
mock.lockGetPowerManagementLimitConstraints.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPowerManagementMode calls GetPowerManagementModeFunc.
|
|
func (mock *Device) GetPowerManagementMode() (nvml.EnableState, nvml.Return) {
|
|
if mock.GetPowerManagementModeFunc == nil {
|
|
panic("Device.GetPowerManagementModeFunc: method is nil but Device.GetPowerManagementMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetPowerManagementMode.Lock()
|
|
mock.calls.GetPowerManagementMode = append(mock.calls.GetPowerManagementMode, callInfo)
|
|
mock.lockGetPowerManagementMode.Unlock()
|
|
return mock.GetPowerManagementModeFunc()
|
|
}
|
|
|
|
// GetPowerManagementModeCalls gets all the calls that were made to GetPowerManagementMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPowerManagementModeCalls())
|
|
func (mock *Device) GetPowerManagementModeCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetPowerManagementMode.RLock()
|
|
calls = mock.calls.GetPowerManagementMode
|
|
mock.lockGetPowerManagementMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPowerSource calls GetPowerSourceFunc.
|
|
func (mock *Device) GetPowerSource() (nvml.PowerSource, nvml.Return) {
|
|
if mock.GetPowerSourceFunc == nil {
|
|
panic("Device.GetPowerSourceFunc: method is nil but Device.GetPowerSource was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetPowerSource.Lock()
|
|
mock.calls.GetPowerSource = append(mock.calls.GetPowerSource, callInfo)
|
|
mock.lockGetPowerSource.Unlock()
|
|
return mock.GetPowerSourceFunc()
|
|
}
|
|
|
|
// GetPowerSourceCalls gets all the calls that were made to GetPowerSource.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPowerSourceCalls())
|
|
func (mock *Device) GetPowerSourceCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetPowerSource.RLock()
|
|
calls = mock.calls.GetPowerSource
|
|
mock.lockGetPowerSource.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPowerState calls GetPowerStateFunc.
|
|
func (mock *Device) GetPowerState() (nvml.Pstates, nvml.Return) {
|
|
if mock.GetPowerStateFunc == nil {
|
|
panic("Device.GetPowerStateFunc: method is nil but Device.GetPowerState was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetPowerState.Lock()
|
|
mock.calls.GetPowerState = append(mock.calls.GetPowerState, callInfo)
|
|
mock.lockGetPowerState.Unlock()
|
|
return mock.GetPowerStateFunc()
|
|
}
|
|
|
|
// GetPowerStateCalls gets all the calls that were made to GetPowerState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPowerStateCalls())
|
|
func (mock *Device) GetPowerStateCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetPowerState.RLock()
|
|
calls = mock.calls.GetPowerState
|
|
mock.lockGetPowerState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetPowerUsage calls GetPowerUsageFunc.
|
|
func (mock *Device) GetPowerUsage() (uint32, nvml.Return) {
|
|
if mock.GetPowerUsageFunc == nil {
|
|
panic("Device.GetPowerUsageFunc: method is nil but Device.GetPowerUsage was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetPowerUsage.Lock()
|
|
mock.calls.GetPowerUsage = append(mock.calls.GetPowerUsage, callInfo)
|
|
mock.lockGetPowerUsage.Unlock()
|
|
return mock.GetPowerUsageFunc()
|
|
}
|
|
|
|
// GetPowerUsageCalls gets all the calls that were made to GetPowerUsage.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetPowerUsageCalls())
|
|
func (mock *Device) GetPowerUsageCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetPowerUsage.RLock()
|
|
calls = mock.calls.GetPowerUsage
|
|
mock.lockGetPowerUsage.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetProcessUtilization calls GetProcessUtilizationFunc.
|
|
func (mock *Device) GetProcessUtilization(v uint64) ([]nvml.ProcessUtilizationSample, nvml.Return) {
|
|
if mock.GetProcessUtilizationFunc == nil {
|
|
panic("Device.GetProcessUtilizationFunc: method is nil but Device.GetProcessUtilization was just called")
|
|
}
|
|
callInfo := struct {
|
|
V uint64
|
|
}{
|
|
V: v,
|
|
}
|
|
mock.lockGetProcessUtilization.Lock()
|
|
mock.calls.GetProcessUtilization = append(mock.calls.GetProcessUtilization, callInfo)
|
|
mock.lockGetProcessUtilization.Unlock()
|
|
return mock.GetProcessUtilizationFunc(v)
|
|
}
|
|
|
|
// GetProcessUtilizationCalls gets all the calls that were made to GetProcessUtilization.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetProcessUtilizationCalls())
|
|
func (mock *Device) GetProcessUtilizationCalls() []struct {
|
|
V uint64
|
|
} {
|
|
var calls []struct {
|
|
V uint64
|
|
}
|
|
mock.lockGetProcessUtilization.RLock()
|
|
calls = mock.calls.GetProcessUtilization
|
|
mock.lockGetProcessUtilization.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetRemappedRows calls GetRemappedRowsFunc.
|
|
func (mock *Device) GetRemappedRows() (int, int, bool, bool, nvml.Return) {
|
|
if mock.GetRemappedRowsFunc == nil {
|
|
panic("Device.GetRemappedRowsFunc: method is nil but Device.GetRemappedRows was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetRemappedRows.Lock()
|
|
mock.calls.GetRemappedRows = append(mock.calls.GetRemappedRows, callInfo)
|
|
mock.lockGetRemappedRows.Unlock()
|
|
return mock.GetRemappedRowsFunc()
|
|
}
|
|
|
|
// GetRemappedRowsCalls gets all the calls that were made to GetRemappedRows.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetRemappedRowsCalls())
|
|
func (mock *Device) GetRemappedRowsCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetRemappedRows.RLock()
|
|
calls = mock.calls.GetRemappedRows
|
|
mock.lockGetRemappedRows.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetRetiredPages calls GetRetiredPagesFunc.
|
|
func (mock *Device) GetRetiredPages(pageRetirementCause nvml.PageRetirementCause) ([]uint64, nvml.Return) {
|
|
if mock.GetRetiredPagesFunc == nil {
|
|
panic("Device.GetRetiredPagesFunc: method is nil but Device.GetRetiredPages was just called")
|
|
}
|
|
callInfo := struct {
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
}{
|
|
PageRetirementCause: pageRetirementCause,
|
|
}
|
|
mock.lockGetRetiredPages.Lock()
|
|
mock.calls.GetRetiredPages = append(mock.calls.GetRetiredPages, callInfo)
|
|
mock.lockGetRetiredPages.Unlock()
|
|
return mock.GetRetiredPagesFunc(pageRetirementCause)
|
|
}
|
|
|
|
// GetRetiredPagesCalls gets all the calls that were made to GetRetiredPages.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetRetiredPagesCalls())
|
|
func (mock *Device) GetRetiredPagesCalls() []struct {
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
} {
|
|
var calls []struct {
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
}
|
|
mock.lockGetRetiredPages.RLock()
|
|
calls = mock.calls.GetRetiredPages
|
|
mock.lockGetRetiredPages.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetRetiredPagesPendingStatus calls GetRetiredPagesPendingStatusFunc.
|
|
func (mock *Device) GetRetiredPagesPendingStatus() (nvml.EnableState, nvml.Return) {
|
|
if mock.GetRetiredPagesPendingStatusFunc == nil {
|
|
panic("Device.GetRetiredPagesPendingStatusFunc: method is nil but Device.GetRetiredPagesPendingStatus was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetRetiredPagesPendingStatus.Lock()
|
|
mock.calls.GetRetiredPagesPendingStatus = append(mock.calls.GetRetiredPagesPendingStatus, callInfo)
|
|
mock.lockGetRetiredPagesPendingStatus.Unlock()
|
|
return mock.GetRetiredPagesPendingStatusFunc()
|
|
}
|
|
|
|
// GetRetiredPagesPendingStatusCalls gets all the calls that were made to GetRetiredPagesPendingStatus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetRetiredPagesPendingStatusCalls())
|
|
func (mock *Device) GetRetiredPagesPendingStatusCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetRetiredPagesPendingStatus.RLock()
|
|
calls = mock.calls.GetRetiredPagesPendingStatus
|
|
mock.lockGetRetiredPagesPendingStatus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetRetiredPages_v2 calls GetRetiredPages_v2Func.
|
|
func (mock *Device) GetRetiredPages_v2(pageRetirementCause nvml.PageRetirementCause) ([]uint64, []uint64, nvml.Return) {
|
|
if mock.GetRetiredPages_v2Func == nil {
|
|
panic("Device.GetRetiredPages_v2Func: method is nil but Device.GetRetiredPages_v2 was just called")
|
|
}
|
|
callInfo := struct {
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
}{
|
|
PageRetirementCause: pageRetirementCause,
|
|
}
|
|
mock.lockGetRetiredPages_v2.Lock()
|
|
mock.calls.GetRetiredPages_v2 = append(mock.calls.GetRetiredPages_v2, callInfo)
|
|
mock.lockGetRetiredPages_v2.Unlock()
|
|
return mock.GetRetiredPages_v2Func(pageRetirementCause)
|
|
}
|
|
|
|
// GetRetiredPages_v2Calls gets all the calls that were made to GetRetiredPages_v2.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetRetiredPages_v2Calls())
|
|
func (mock *Device) GetRetiredPages_v2Calls() []struct {
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
} {
|
|
var calls []struct {
|
|
PageRetirementCause nvml.PageRetirementCause
|
|
}
|
|
mock.lockGetRetiredPages_v2.RLock()
|
|
calls = mock.calls.GetRetiredPages_v2
|
|
mock.lockGetRetiredPages_v2.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetRowRemapperHistogram calls GetRowRemapperHistogramFunc.
|
|
func (mock *Device) GetRowRemapperHistogram() (nvml.RowRemapperHistogramValues, nvml.Return) {
|
|
if mock.GetRowRemapperHistogramFunc == nil {
|
|
panic("Device.GetRowRemapperHistogramFunc: method is nil but Device.GetRowRemapperHistogram was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetRowRemapperHistogram.Lock()
|
|
mock.calls.GetRowRemapperHistogram = append(mock.calls.GetRowRemapperHistogram, callInfo)
|
|
mock.lockGetRowRemapperHistogram.Unlock()
|
|
return mock.GetRowRemapperHistogramFunc()
|
|
}
|
|
|
|
// GetRowRemapperHistogramCalls gets all the calls that were made to GetRowRemapperHistogram.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetRowRemapperHistogramCalls())
|
|
func (mock *Device) GetRowRemapperHistogramCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetRowRemapperHistogram.RLock()
|
|
calls = mock.calls.GetRowRemapperHistogram
|
|
mock.lockGetRowRemapperHistogram.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetSamples calls GetSamplesFunc.
|
|
func (mock *Device) GetSamples(samplingType nvml.SamplingType, v uint64) (nvml.ValueType, []nvml.Sample, nvml.Return) {
|
|
if mock.GetSamplesFunc == nil {
|
|
panic("Device.GetSamplesFunc: method is nil but Device.GetSamples was just called")
|
|
}
|
|
callInfo := struct {
|
|
SamplingType nvml.SamplingType
|
|
V uint64
|
|
}{
|
|
SamplingType: samplingType,
|
|
V: v,
|
|
}
|
|
mock.lockGetSamples.Lock()
|
|
mock.calls.GetSamples = append(mock.calls.GetSamples, callInfo)
|
|
mock.lockGetSamples.Unlock()
|
|
return mock.GetSamplesFunc(samplingType, v)
|
|
}
|
|
|
|
// GetSamplesCalls gets all the calls that were made to GetSamples.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetSamplesCalls())
|
|
func (mock *Device) GetSamplesCalls() []struct {
|
|
SamplingType nvml.SamplingType
|
|
V uint64
|
|
} {
|
|
var calls []struct {
|
|
SamplingType nvml.SamplingType
|
|
V uint64
|
|
}
|
|
mock.lockGetSamples.RLock()
|
|
calls = mock.calls.GetSamples
|
|
mock.lockGetSamples.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetSerial calls GetSerialFunc.
|
|
func (mock *Device) GetSerial() (string, nvml.Return) {
|
|
if mock.GetSerialFunc == nil {
|
|
panic("Device.GetSerialFunc: method is nil but Device.GetSerial was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetSerial.Lock()
|
|
mock.calls.GetSerial = append(mock.calls.GetSerial, callInfo)
|
|
mock.lockGetSerial.Unlock()
|
|
return mock.GetSerialFunc()
|
|
}
|
|
|
|
// GetSerialCalls gets all the calls that were made to GetSerial.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetSerialCalls())
|
|
func (mock *Device) GetSerialCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetSerial.RLock()
|
|
calls = mock.calls.GetSerial
|
|
mock.lockGetSerial.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetSupportedClocksThrottleReasons calls GetSupportedClocksThrottleReasonsFunc.
|
|
func (mock *Device) GetSupportedClocksThrottleReasons() (uint64, nvml.Return) {
|
|
if mock.GetSupportedClocksThrottleReasonsFunc == nil {
|
|
panic("Device.GetSupportedClocksThrottleReasonsFunc: method is nil but Device.GetSupportedClocksThrottleReasons was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetSupportedClocksThrottleReasons.Lock()
|
|
mock.calls.GetSupportedClocksThrottleReasons = append(mock.calls.GetSupportedClocksThrottleReasons, callInfo)
|
|
mock.lockGetSupportedClocksThrottleReasons.Unlock()
|
|
return mock.GetSupportedClocksThrottleReasonsFunc()
|
|
}
|
|
|
|
// GetSupportedClocksThrottleReasonsCalls gets all the calls that were made to GetSupportedClocksThrottleReasons.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetSupportedClocksThrottleReasonsCalls())
|
|
func (mock *Device) GetSupportedClocksThrottleReasonsCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetSupportedClocksThrottleReasons.RLock()
|
|
calls = mock.calls.GetSupportedClocksThrottleReasons
|
|
mock.lockGetSupportedClocksThrottleReasons.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetSupportedEventTypes calls GetSupportedEventTypesFunc.
|
|
func (mock *Device) GetSupportedEventTypes() (uint64, nvml.Return) {
|
|
if mock.GetSupportedEventTypesFunc == nil {
|
|
panic("Device.GetSupportedEventTypesFunc: method is nil but Device.GetSupportedEventTypes was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetSupportedEventTypes.Lock()
|
|
mock.calls.GetSupportedEventTypes = append(mock.calls.GetSupportedEventTypes, callInfo)
|
|
mock.lockGetSupportedEventTypes.Unlock()
|
|
return mock.GetSupportedEventTypesFunc()
|
|
}
|
|
|
|
// GetSupportedEventTypesCalls gets all the calls that were made to GetSupportedEventTypes.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetSupportedEventTypesCalls())
|
|
func (mock *Device) GetSupportedEventTypesCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetSupportedEventTypes.RLock()
|
|
calls = mock.calls.GetSupportedEventTypes
|
|
mock.lockGetSupportedEventTypes.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetSupportedGraphicsClocks calls GetSupportedGraphicsClocksFunc.
|
|
func (mock *Device) GetSupportedGraphicsClocks(n int) (int, uint32, nvml.Return) {
|
|
if mock.GetSupportedGraphicsClocksFunc == nil {
|
|
panic("Device.GetSupportedGraphicsClocksFunc: method is nil but Device.GetSupportedGraphicsClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockGetSupportedGraphicsClocks.Lock()
|
|
mock.calls.GetSupportedGraphicsClocks = append(mock.calls.GetSupportedGraphicsClocks, callInfo)
|
|
mock.lockGetSupportedGraphicsClocks.Unlock()
|
|
return mock.GetSupportedGraphicsClocksFunc(n)
|
|
}
|
|
|
|
// GetSupportedGraphicsClocksCalls gets all the calls that were made to GetSupportedGraphicsClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetSupportedGraphicsClocksCalls())
|
|
func (mock *Device) GetSupportedGraphicsClocksCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockGetSupportedGraphicsClocks.RLock()
|
|
calls = mock.calls.GetSupportedGraphicsClocks
|
|
mock.lockGetSupportedGraphicsClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetSupportedMemoryClocks calls GetSupportedMemoryClocksFunc.
|
|
func (mock *Device) GetSupportedMemoryClocks() (int, uint32, nvml.Return) {
|
|
if mock.GetSupportedMemoryClocksFunc == nil {
|
|
panic("Device.GetSupportedMemoryClocksFunc: method is nil but Device.GetSupportedMemoryClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetSupportedMemoryClocks.Lock()
|
|
mock.calls.GetSupportedMemoryClocks = append(mock.calls.GetSupportedMemoryClocks, callInfo)
|
|
mock.lockGetSupportedMemoryClocks.Unlock()
|
|
return mock.GetSupportedMemoryClocksFunc()
|
|
}
|
|
|
|
// GetSupportedMemoryClocksCalls gets all the calls that were made to GetSupportedMemoryClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetSupportedMemoryClocksCalls())
|
|
func (mock *Device) GetSupportedMemoryClocksCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetSupportedMemoryClocks.RLock()
|
|
calls = mock.calls.GetSupportedMemoryClocks
|
|
mock.lockGetSupportedMemoryClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetSupportedPerformanceStates calls GetSupportedPerformanceStatesFunc.
|
|
func (mock *Device) GetSupportedPerformanceStates() ([]nvml.Pstates, nvml.Return) {
|
|
if mock.GetSupportedPerformanceStatesFunc == nil {
|
|
panic("Device.GetSupportedPerformanceStatesFunc: method is nil but Device.GetSupportedPerformanceStates was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetSupportedPerformanceStates.Lock()
|
|
mock.calls.GetSupportedPerformanceStates = append(mock.calls.GetSupportedPerformanceStates, callInfo)
|
|
mock.lockGetSupportedPerformanceStates.Unlock()
|
|
return mock.GetSupportedPerformanceStatesFunc()
|
|
}
|
|
|
|
// GetSupportedPerformanceStatesCalls gets all the calls that were made to GetSupportedPerformanceStates.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetSupportedPerformanceStatesCalls())
|
|
func (mock *Device) GetSupportedPerformanceStatesCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetSupportedPerformanceStates.RLock()
|
|
calls = mock.calls.GetSupportedPerformanceStates
|
|
mock.lockGetSupportedPerformanceStates.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetSupportedVgpus calls GetSupportedVgpusFunc.
|
|
func (mock *Device) GetSupportedVgpus() ([]nvml.VgpuTypeId, nvml.Return) {
|
|
if mock.GetSupportedVgpusFunc == nil {
|
|
panic("Device.GetSupportedVgpusFunc: method is nil but Device.GetSupportedVgpus was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetSupportedVgpus.Lock()
|
|
mock.calls.GetSupportedVgpus = append(mock.calls.GetSupportedVgpus, callInfo)
|
|
mock.lockGetSupportedVgpus.Unlock()
|
|
return mock.GetSupportedVgpusFunc()
|
|
}
|
|
|
|
// GetSupportedVgpusCalls gets all the calls that were made to GetSupportedVgpus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetSupportedVgpusCalls())
|
|
func (mock *Device) GetSupportedVgpusCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetSupportedVgpus.RLock()
|
|
calls = mock.calls.GetSupportedVgpus
|
|
mock.lockGetSupportedVgpus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetTargetFanSpeed calls GetTargetFanSpeedFunc.
|
|
func (mock *Device) GetTargetFanSpeed(n int) (int, nvml.Return) {
|
|
if mock.GetTargetFanSpeedFunc == nil {
|
|
panic("Device.GetTargetFanSpeedFunc: method is nil but Device.GetTargetFanSpeed was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockGetTargetFanSpeed.Lock()
|
|
mock.calls.GetTargetFanSpeed = append(mock.calls.GetTargetFanSpeed, callInfo)
|
|
mock.lockGetTargetFanSpeed.Unlock()
|
|
return mock.GetTargetFanSpeedFunc(n)
|
|
}
|
|
|
|
// GetTargetFanSpeedCalls gets all the calls that were made to GetTargetFanSpeed.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetTargetFanSpeedCalls())
|
|
func (mock *Device) GetTargetFanSpeedCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockGetTargetFanSpeed.RLock()
|
|
calls = mock.calls.GetTargetFanSpeed
|
|
mock.lockGetTargetFanSpeed.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetTemperature calls GetTemperatureFunc.
|
|
func (mock *Device) GetTemperature(temperatureSensors nvml.TemperatureSensors) (uint32, nvml.Return) {
|
|
if mock.GetTemperatureFunc == nil {
|
|
panic("Device.GetTemperatureFunc: method is nil but Device.GetTemperature was just called")
|
|
}
|
|
callInfo := struct {
|
|
TemperatureSensors nvml.TemperatureSensors
|
|
}{
|
|
TemperatureSensors: temperatureSensors,
|
|
}
|
|
mock.lockGetTemperature.Lock()
|
|
mock.calls.GetTemperature = append(mock.calls.GetTemperature, callInfo)
|
|
mock.lockGetTemperature.Unlock()
|
|
return mock.GetTemperatureFunc(temperatureSensors)
|
|
}
|
|
|
|
// GetTemperatureCalls gets all the calls that were made to GetTemperature.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetTemperatureCalls())
|
|
func (mock *Device) GetTemperatureCalls() []struct {
|
|
TemperatureSensors nvml.TemperatureSensors
|
|
} {
|
|
var calls []struct {
|
|
TemperatureSensors nvml.TemperatureSensors
|
|
}
|
|
mock.lockGetTemperature.RLock()
|
|
calls = mock.calls.GetTemperature
|
|
mock.lockGetTemperature.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetTemperatureThreshold calls GetTemperatureThresholdFunc.
|
|
func (mock *Device) GetTemperatureThreshold(temperatureThresholds nvml.TemperatureThresholds) (uint32, nvml.Return) {
|
|
if mock.GetTemperatureThresholdFunc == nil {
|
|
panic("Device.GetTemperatureThresholdFunc: method is nil but Device.GetTemperatureThreshold was just called")
|
|
}
|
|
callInfo := struct {
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
}{
|
|
TemperatureThresholds: temperatureThresholds,
|
|
}
|
|
mock.lockGetTemperatureThreshold.Lock()
|
|
mock.calls.GetTemperatureThreshold = append(mock.calls.GetTemperatureThreshold, callInfo)
|
|
mock.lockGetTemperatureThreshold.Unlock()
|
|
return mock.GetTemperatureThresholdFunc(temperatureThresholds)
|
|
}
|
|
|
|
// GetTemperatureThresholdCalls gets all the calls that were made to GetTemperatureThreshold.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetTemperatureThresholdCalls())
|
|
func (mock *Device) GetTemperatureThresholdCalls() []struct {
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
} {
|
|
var calls []struct {
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
}
|
|
mock.lockGetTemperatureThreshold.RLock()
|
|
calls = mock.calls.GetTemperatureThreshold
|
|
mock.lockGetTemperatureThreshold.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetThermalSettings calls GetThermalSettingsFunc.
|
|
func (mock *Device) GetThermalSettings(v uint32) (nvml.GpuThermalSettings, nvml.Return) {
|
|
if mock.GetThermalSettingsFunc == nil {
|
|
panic("Device.GetThermalSettingsFunc: method is nil but Device.GetThermalSettings was just called")
|
|
}
|
|
callInfo := struct {
|
|
V uint32
|
|
}{
|
|
V: v,
|
|
}
|
|
mock.lockGetThermalSettings.Lock()
|
|
mock.calls.GetThermalSettings = append(mock.calls.GetThermalSettings, callInfo)
|
|
mock.lockGetThermalSettings.Unlock()
|
|
return mock.GetThermalSettingsFunc(v)
|
|
}
|
|
|
|
// GetThermalSettingsCalls gets all the calls that were made to GetThermalSettings.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetThermalSettingsCalls())
|
|
func (mock *Device) GetThermalSettingsCalls() []struct {
|
|
V uint32
|
|
} {
|
|
var calls []struct {
|
|
V uint32
|
|
}
|
|
mock.lockGetThermalSettings.RLock()
|
|
calls = mock.calls.GetThermalSettings
|
|
mock.lockGetThermalSettings.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetTopologyCommonAncestor calls GetTopologyCommonAncestorFunc.
|
|
func (mock *Device) GetTopologyCommonAncestor(device nvml.Device) (nvml.GpuTopologyLevel, nvml.Return) {
|
|
if mock.GetTopologyCommonAncestorFunc == nil {
|
|
panic("Device.GetTopologyCommonAncestorFunc: method is nil but Device.GetTopologyCommonAncestor was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockGetTopologyCommonAncestor.Lock()
|
|
mock.calls.GetTopologyCommonAncestor = append(mock.calls.GetTopologyCommonAncestor, callInfo)
|
|
mock.lockGetTopologyCommonAncestor.Unlock()
|
|
return mock.GetTopologyCommonAncestorFunc(device)
|
|
}
|
|
|
|
// GetTopologyCommonAncestorCalls gets all the calls that were made to GetTopologyCommonAncestor.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetTopologyCommonAncestorCalls())
|
|
func (mock *Device) GetTopologyCommonAncestorCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockGetTopologyCommonAncestor.RLock()
|
|
calls = mock.calls.GetTopologyCommonAncestor
|
|
mock.lockGetTopologyCommonAncestor.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetTopologyNearestGpus calls GetTopologyNearestGpusFunc.
|
|
func (mock *Device) GetTopologyNearestGpus(gpuTopologyLevel nvml.GpuTopologyLevel) ([]nvml.Device, nvml.Return) {
|
|
if mock.GetTopologyNearestGpusFunc == nil {
|
|
panic("Device.GetTopologyNearestGpusFunc: method is nil but Device.GetTopologyNearestGpus was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuTopologyLevel nvml.GpuTopologyLevel
|
|
}{
|
|
GpuTopologyLevel: gpuTopologyLevel,
|
|
}
|
|
mock.lockGetTopologyNearestGpus.Lock()
|
|
mock.calls.GetTopologyNearestGpus = append(mock.calls.GetTopologyNearestGpus, callInfo)
|
|
mock.lockGetTopologyNearestGpus.Unlock()
|
|
return mock.GetTopologyNearestGpusFunc(gpuTopologyLevel)
|
|
}
|
|
|
|
// GetTopologyNearestGpusCalls gets all the calls that were made to GetTopologyNearestGpus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetTopologyNearestGpusCalls())
|
|
func (mock *Device) GetTopologyNearestGpusCalls() []struct {
|
|
GpuTopologyLevel nvml.GpuTopologyLevel
|
|
} {
|
|
var calls []struct {
|
|
GpuTopologyLevel nvml.GpuTopologyLevel
|
|
}
|
|
mock.lockGetTopologyNearestGpus.RLock()
|
|
calls = mock.calls.GetTopologyNearestGpus
|
|
mock.lockGetTopologyNearestGpus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetTotalEccErrors calls GetTotalEccErrorsFunc.
|
|
func (mock *Device) GetTotalEccErrors(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (uint64, nvml.Return) {
|
|
if mock.GetTotalEccErrorsFunc == nil {
|
|
panic("Device.GetTotalEccErrorsFunc: method is nil but Device.GetTotalEccErrors was just called")
|
|
}
|
|
callInfo := struct {
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
}{
|
|
MemoryErrorType: memoryErrorType,
|
|
EccCounterType: eccCounterType,
|
|
}
|
|
mock.lockGetTotalEccErrors.Lock()
|
|
mock.calls.GetTotalEccErrors = append(mock.calls.GetTotalEccErrors, callInfo)
|
|
mock.lockGetTotalEccErrors.Unlock()
|
|
return mock.GetTotalEccErrorsFunc(memoryErrorType, eccCounterType)
|
|
}
|
|
|
|
// GetTotalEccErrorsCalls gets all the calls that were made to GetTotalEccErrors.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetTotalEccErrorsCalls())
|
|
func (mock *Device) GetTotalEccErrorsCalls() []struct {
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
} {
|
|
var calls []struct {
|
|
MemoryErrorType nvml.MemoryErrorType
|
|
EccCounterType nvml.EccCounterType
|
|
}
|
|
mock.lockGetTotalEccErrors.RLock()
|
|
calls = mock.calls.GetTotalEccErrors
|
|
mock.lockGetTotalEccErrors.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetTotalEnergyConsumption calls GetTotalEnergyConsumptionFunc.
|
|
func (mock *Device) GetTotalEnergyConsumption() (uint64, nvml.Return) {
|
|
if mock.GetTotalEnergyConsumptionFunc == nil {
|
|
panic("Device.GetTotalEnergyConsumptionFunc: method is nil but Device.GetTotalEnergyConsumption was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetTotalEnergyConsumption.Lock()
|
|
mock.calls.GetTotalEnergyConsumption = append(mock.calls.GetTotalEnergyConsumption, callInfo)
|
|
mock.lockGetTotalEnergyConsumption.Unlock()
|
|
return mock.GetTotalEnergyConsumptionFunc()
|
|
}
|
|
|
|
// GetTotalEnergyConsumptionCalls gets all the calls that were made to GetTotalEnergyConsumption.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetTotalEnergyConsumptionCalls())
|
|
func (mock *Device) GetTotalEnergyConsumptionCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetTotalEnergyConsumption.RLock()
|
|
calls = mock.calls.GetTotalEnergyConsumption
|
|
mock.lockGetTotalEnergyConsumption.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetUUID calls GetUUIDFunc.
|
|
func (mock *Device) GetUUID() (string, nvml.Return) {
|
|
if mock.GetUUIDFunc == nil {
|
|
panic("Device.GetUUIDFunc: method is nil but Device.GetUUID was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetUUID.Lock()
|
|
mock.calls.GetUUID = append(mock.calls.GetUUID, callInfo)
|
|
mock.lockGetUUID.Unlock()
|
|
return mock.GetUUIDFunc()
|
|
}
|
|
|
|
// GetUUIDCalls gets all the calls that were made to GetUUID.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetUUIDCalls())
|
|
func (mock *Device) GetUUIDCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetUUID.RLock()
|
|
calls = mock.calls.GetUUID
|
|
mock.lockGetUUID.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetUtilizationRates calls GetUtilizationRatesFunc.
|
|
func (mock *Device) GetUtilizationRates() (nvml.Utilization, nvml.Return) {
|
|
if mock.GetUtilizationRatesFunc == nil {
|
|
panic("Device.GetUtilizationRatesFunc: method is nil but Device.GetUtilizationRates was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetUtilizationRates.Lock()
|
|
mock.calls.GetUtilizationRates = append(mock.calls.GetUtilizationRates, callInfo)
|
|
mock.lockGetUtilizationRates.Unlock()
|
|
return mock.GetUtilizationRatesFunc()
|
|
}
|
|
|
|
// GetUtilizationRatesCalls gets all the calls that were made to GetUtilizationRates.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetUtilizationRatesCalls())
|
|
func (mock *Device) GetUtilizationRatesCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetUtilizationRates.RLock()
|
|
calls = mock.calls.GetUtilizationRates
|
|
mock.lockGetUtilizationRates.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetVbiosVersion calls GetVbiosVersionFunc.
|
|
func (mock *Device) GetVbiosVersion() (string, nvml.Return) {
|
|
if mock.GetVbiosVersionFunc == nil {
|
|
panic("Device.GetVbiosVersionFunc: method is nil but Device.GetVbiosVersion was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetVbiosVersion.Lock()
|
|
mock.calls.GetVbiosVersion = append(mock.calls.GetVbiosVersion, callInfo)
|
|
mock.lockGetVbiosVersion.Unlock()
|
|
return mock.GetVbiosVersionFunc()
|
|
}
|
|
|
|
// GetVbiosVersionCalls gets all the calls that were made to GetVbiosVersion.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetVbiosVersionCalls())
|
|
func (mock *Device) GetVbiosVersionCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetVbiosVersion.RLock()
|
|
calls = mock.calls.GetVbiosVersion
|
|
mock.lockGetVbiosVersion.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetVgpuCapabilities calls GetVgpuCapabilitiesFunc.
|
|
func (mock *Device) GetVgpuCapabilities(deviceVgpuCapability nvml.DeviceVgpuCapability) (bool, nvml.Return) {
|
|
if mock.GetVgpuCapabilitiesFunc == nil {
|
|
panic("Device.GetVgpuCapabilitiesFunc: method is nil but Device.GetVgpuCapabilities was just called")
|
|
}
|
|
callInfo := struct {
|
|
DeviceVgpuCapability nvml.DeviceVgpuCapability
|
|
}{
|
|
DeviceVgpuCapability: deviceVgpuCapability,
|
|
}
|
|
mock.lockGetVgpuCapabilities.Lock()
|
|
mock.calls.GetVgpuCapabilities = append(mock.calls.GetVgpuCapabilities, callInfo)
|
|
mock.lockGetVgpuCapabilities.Unlock()
|
|
return mock.GetVgpuCapabilitiesFunc(deviceVgpuCapability)
|
|
}
|
|
|
|
// GetVgpuCapabilitiesCalls gets all the calls that were made to GetVgpuCapabilities.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetVgpuCapabilitiesCalls())
|
|
func (mock *Device) GetVgpuCapabilitiesCalls() []struct {
|
|
DeviceVgpuCapability nvml.DeviceVgpuCapability
|
|
} {
|
|
var calls []struct {
|
|
DeviceVgpuCapability nvml.DeviceVgpuCapability
|
|
}
|
|
mock.lockGetVgpuCapabilities.RLock()
|
|
calls = mock.calls.GetVgpuCapabilities
|
|
mock.lockGetVgpuCapabilities.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetVgpuMetadata calls GetVgpuMetadataFunc.
|
|
func (mock *Device) GetVgpuMetadata() (nvml.VgpuPgpuMetadata, nvml.Return) {
|
|
if mock.GetVgpuMetadataFunc == nil {
|
|
panic("Device.GetVgpuMetadataFunc: method is nil but Device.GetVgpuMetadata was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetVgpuMetadata.Lock()
|
|
mock.calls.GetVgpuMetadata = append(mock.calls.GetVgpuMetadata, callInfo)
|
|
mock.lockGetVgpuMetadata.Unlock()
|
|
return mock.GetVgpuMetadataFunc()
|
|
}
|
|
|
|
// GetVgpuMetadataCalls gets all the calls that were made to GetVgpuMetadata.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetVgpuMetadataCalls())
|
|
func (mock *Device) GetVgpuMetadataCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetVgpuMetadata.RLock()
|
|
calls = mock.calls.GetVgpuMetadata
|
|
mock.lockGetVgpuMetadata.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetVgpuProcessUtilization calls GetVgpuProcessUtilizationFunc.
|
|
func (mock *Device) GetVgpuProcessUtilization(v uint64) ([]nvml.VgpuProcessUtilizationSample, nvml.Return) {
|
|
if mock.GetVgpuProcessUtilizationFunc == nil {
|
|
panic("Device.GetVgpuProcessUtilizationFunc: method is nil but Device.GetVgpuProcessUtilization was just called")
|
|
}
|
|
callInfo := struct {
|
|
V uint64
|
|
}{
|
|
V: v,
|
|
}
|
|
mock.lockGetVgpuProcessUtilization.Lock()
|
|
mock.calls.GetVgpuProcessUtilization = append(mock.calls.GetVgpuProcessUtilization, callInfo)
|
|
mock.lockGetVgpuProcessUtilization.Unlock()
|
|
return mock.GetVgpuProcessUtilizationFunc(v)
|
|
}
|
|
|
|
// GetVgpuProcessUtilizationCalls gets all the calls that were made to GetVgpuProcessUtilization.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetVgpuProcessUtilizationCalls())
|
|
func (mock *Device) GetVgpuProcessUtilizationCalls() []struct {
|
|
V uint64
|
|
} {
|
|
var calls []struct {
|
|
V uint64
|
|
}
|
|
mock.lockGetVgpuProcessUtilization.RLock()
|
|
calls = mock.calls.GetVgpuProcessUtilization
|
|
mock.lockGetVgpuProcessUtilization.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetVgpuSchedulerCapabilities calls GetVgpuSchedulerCapabilitiesFunc.
|
|
func (mock *Device) GetVgpuSchedulerCapabilities() (nvml.VgpuSchedulerCapabilities, nvml.Return) {
|
|
if mock.GetVgpuSchedulerCapabilitiesFunc == nil {
|
|
panic("Device.GetVgpuSchedulerCapabilitiesFunc: method is nil but Device.GetVgpuSchedulerCapabilities was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetVgpuSchedulerCapabilities.Lock()
|
|
mock.calls.GetVgpuSchedulerCapabilities = append(mock.calls.GetVgpuSchedulerCapabilities, callInfo)
|
|
mock.lockGetVgpuSchedulerCapabilities.Unlock()
|
|
return mock.GetVgpuSchedulerCapabilitiesFunc()
|
|
}
|
|
|
|
// GetVgpuSchedulerCapabilitiesCalls gets all the calls that were made to GetVgpuSchedulerCapabilities.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetVgpuSchedulerCapabilitiesCalls())
|
|
func (mock *Device) GetVgpuSchedulerCapabilitiesCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetVgpuSchedulerCapabilities.RLock()
|
|
calls = mock.calls.GetVgpuSchedulerCapabilities
|
|
mock.lockGetVgpuSchedulerCapabilities.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetVgpuSchedulerLog calls GetVgpuSchedulerLogFunc.
|
|
func (mock *Device) GetVgpuSchedulerLog() (nvml.VgpuSchedulerLog, nvml.Return) {
|
|
if mock.GetVgpuSchedulerLogFunc == nil {
|
|
panic("Device.GetVgpuSchedulerLogFunc: method is nil but Device.GetVgpuSchedulerLog was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetVgpuSchedulerLog.Lock()
|
|
mock.calls.GetVgpuSchedulerLog = append(mock.calls.GetVgpuSchedulerLog, callInfo)
|
|
mock.lockGetVgpuSchedulerLog.Unlock()
|
|
return mock.GetVgpuSchedulerLogFunc()
|
|
}
|
|
|
|
// GetVgpuSchedulerLogCalls gets all the calls that were made to GetVgpuSchedulerLog.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetVgpuSchedulerLogCalls())
|
|
func (mock *Device) GetVgpuSchedulerLogCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetVgpuSchedulerLog.RLock()
|
|
calls = mock.calls.GetVgpuSchedulerLog
|
|
mock.lockGetVgpuSchedulerLog.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetVgpuSchedulerState calls GetVgpuSchedulerStateFunc.
|
|
func (mock *Device) GetVgpuSchedulerState() (nvml.VgpuSchedulerGetState, nvml.Return) {
|
|
if mock.GetVgpuSchedulerStateFunc == nil {
|
|
panic("Device.GetVgpuSchedulerStateFunc: method is nil but Device.GetVgpuSchedulerState was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetVgpuSchedulerState.Lock()
|
|
mock.calls.GetVgpuSchedulerState = append(mock.calls.GetVgpuSchedulerState, callInfo)
|
|
mock.lockGetVgpuSchedulerState.Unlock()
|
|
return mock.GetVgpuSchedulerStateFunc()
|
|
}
|
|
|
|
// GetVgpuSchedulerStateCalls gets all the calls that were made to GetVgpuSchedulerState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetVgpuSchedulerStateCalls())
|
|
func (mock *Device) GetVgpuSchedulerStateCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetVgpuSchedulerState.RLock()
|
|
calls = mock.calls.GetVgpuSchedulerState
|
|
mock.lockGetVgpuSchedulerState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetVgpuUtilization calls GetVgpuUtilizationFunc.
|
|
func (mock *Device) GetVgpuUtilization(v uint64) (nvml.ValueType, []nvml.VgpuInstanceUtilizationSample, nvml.Return) {
|
|
if mock.GetVgpuUtilizationFunc == nil {
|
|
panic("Device.GetVgpuUtilizationFunc: method is nil but Device.GetVgpuUtilization was just called")
|
|
}
|
|
callInfo := struct {
|
|
V uint64
|
|
}{
|
|
V: v,
|
|
}
|
|
mock.lockGetVgpuUtilization.Lock()
|
|
mock.calls.GetVgpuUtilization = append(mock.calls.GetVgpuUtilization, callInfo)
|
|
mock.lockGetVgpuUtilization.Unlock()
|
|
return mock.GetVgpuUtilizationFunc(v)
|
|
}
|
|
|
|
// GetVgpuUtilizationCalls gets all the calls that were made to GetVgpuUtilization.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetVgpuUtilizationCalls())
|
|
func (mock *Device) GetVgpuUtilizationCalls() []struct {
|
|
V uint64
|
|
} {
|
|
var calls []struct {
|
|
V uint64
|
|
}
|
|
mock.lockGetVgpuUtilization.RLock()
|
|
calls = mock.calls.GetVgpuUtilization
|
|
mock.lockGetVgpuUtilization.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetViolationStatus calls GetViolationStatusFunc.
|
|
func (mock *Device) GetViolationStatus(perfPolicyType nvml.PerfPolicyType) (nvml.ViolationTime, nvml.Return) {
|
|
if mock.GetViolationStatusFunc == nil {
|
|
panic("Device.GetViolationStatusFunc: method is nil but Device.GetViolationStatus was just called")
|
|
}
|
|
callInfo := struct {
|
|
PerfPolicyType nvml.PerfPolicyType
|
|
}{
|
|
PerfPolicyType: perfPolicyType,
|
|
}
|
|
mock.lockGetViolationStatus.Lock()
|
|
mock.calls.GetViolationStatus = append(mock.calls.GetViolationStatus, callInfo)
|
|
mock.lockGetViolationStatus.Unlock()
|
|
return mock.GetViolationStatusFunc(perfPolicyType)
|
|
}
|
|
|
|
// GetViolationStatusCalls gets all the calls that were made to GetViolationStatus.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetViolationStatusCalls())
|
|
func (mock *Device) GetViolationStatusCalls() []struct {
|
|
PerfPolicyType nvml.PerfPolicyType
|
|
} {
|
|
var calls []struct {
|
|
PerfPolicyType nvml.PerfPolicyType
|
|
}
|
|
mock.lockGetViolationStatus.RLock()
|
|
calls = mock.calls.GetViolationStatus
|
|
mock.lockGetViolationStatus.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GetVirtualizationMode calls GetVirtualizationModeFunc.
|
|
func (mock *Device) GetVirtualizationMode() (nvml.GpuVirtualizationMode, nvml.Return) {
|
|
if mock.GetVirtualizationModeFunc == nil {
|
|
panic("Device.GetVirtualizationModeFunc: method is nil but Device.GetVirtualizationMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGetVirtualizationMode.Lock()
|
|
mock.calls.GetVirtualizationMode = append(mock.calls.GetVirtualizationMode, callInfo)
|
|
mock.lockGetVirtualizationMode.Unlock()
|
|
return mock.GetVirtualizationModeFunc()
|
|
}
|
|
|
|
// GetVirtualizationModeCalls gets all the calls that were made to GetVirtualizationMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GetVirtualizationModeCalls())
|
|
func (mock *Device) GetVirtualizationModeCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGetVirtualizationMode.RLock()
|
|
calls = mock.calls.GetVirtualizationMode
|
|
mock.lockGetVirtualizationMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpmMigSampleGet calls GpmMigSampleGetFunc.
|
|
func (mock *Device) GpmMigSampleGet(n int, gpmSample nvml.GpmSample) nvml.Return {
|
|
if mock.GpmMigSampleGetFunc == nil {
|
|
panic("Device.GpmMigSampleGetFunc: method is nil but Device.GpmMigSampleGet was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
GpmSample nvml.GpmSample
|
|
}{
|
|
N: n,
|
|
GpmSample: gpmSample,
|
|
}
|
|
mock.lockGpmMigSampleGet.Lock()
|
|
mock.calls.GpmMigSampleGet = append(mock.calls.GpmMigSampleGet, callInfo)
|
|
mock.lockGpmMigSampleGet.Unlock()
|
|
return mock.GpmMigSampleGetFunc(n, gpmSample)
|
|
}
|
|
|
|
// GpmMigSampleGetCalls gets all the calls that were made to GpmMigSampleGet.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GpmMigSampleGetCalls())
|
|
func (mock *Device) GpmMigSampleGetCalls() []struct {
|
|
N int
|
|
GpmSample nvml.GpmSample
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
GpmSample nvml.GpmSample
|
|
}
|
|
mock.lockGpmMigSampleGet.RLock()
|
|
calls = mock.calls.GpmMigSampleGet
|
|
mock.lockGpmMigSampleGet.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpmQueryDeviceSupport calls GpmQueryDeviceSupportFunc.
|
|
func (mock *Device) GpmQueryDeviceSupport() (nvml.GpmSupport, nvml.Return) {
|
|
if mock.GpmQueryDeviceSupportFunc == nil {
|
|
panic("Device.GpmQueryDeviceSupportFunc: method is nil but Device.GpmQueryDeviceSupport was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGpmQueryDeviceSupport.Lock()
|
|
mock.calls.GpmQueryDeviceSupport = append(mock.calls.GpmQueryDeviceSupport, callInfo)
|
|
mock.lockGpmQueryDeviceSupport.Unlock()
|
|
return mock.GpmQueryDeviceSupportFunc()
|
|
}
|
|
|
|
// GpmQueryDeviceSupportCalls gets all the calls that were made to GpmQueryDeviceSupport.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GpmQueryDeviceSupportCalls())
|
|
func (mock *Device) GpmQueryDeviceSupportCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGpmQueryDeviceSupport.RLock()
|
|
calls = mock.calls.GpmQueryDeviceSupport
|
|
mock.lockGpmQueryDeviceSupport.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpmQueryDeviceSupportV calls GpmQueryDeviceSupportVFunc.
|
|
func (mock *Device) GpmQueryDeviceSupportV() nvml.GpmSupportV {
|
|
if mock.GpmQueryDeviceSupportVFunc == nil {
|
|
panic("Device.GpmQueryDeviceSupportVFunc: method is nil but Device.GpmQueryDeviceSupportV was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockGpmQueryDeviceSupportV.Lock()
|
|
mock.calls.GpmQueryDeviceSupportV = append(mock.calls.GpmQueryDeviceSupportV, callInfo)
|
|
mock.lockGpmQueryDeviceSupportV.Unlock()
|
|
return mock.GpmQueryDeviceSupportVFunc()
|
|
}
|
|
|
|
// GpmQueryDeviceSupportVCalls gets all the calls that were made to GpmQueryDeviceSupportV.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GpmQueryDeviceSupportVCalls())
|
|
func (mock *Device) GpmQueryDeviceSupportVCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockGpmQueryDeviceSupportV.RLock()
|
|
calls = mock.calls.GpmQueryDeviceSupportV
|
|
mock.lockGpmQueryDeviceSupportV.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// GpmSampleGet calls GpmSampleGetFunc.
|
|
func (mock *Device) GpmSampleGet(gpmSample nvml.GpmSample) nvml.Return {
|
|
if mock.GpmSampleGetFunc == nil {
|
|
panic("Device.GpmSampleGetFunc: method is nil but Device.GpmSampleGet was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpmSample nvml.GpmSample
|
|
}{
|
|
GpmSample: gpmSample,
|
|
}
|
|
mock.lockGpmSampleGet.Lock()
|
|
mock.calls.GpmSampleGet = append(mock.calls.GpmSampleGet, callInfo)
|
|
mock.lockGpmSampleGet.Unlock()
|
|
return mock.GpmSampleGetFunc(gpmSample)
|
|
}
|
|
|
|
// GpmSampleGetCalls gets all the calls that were made to GpmSampleGet.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.GpmSampleGetCalls())
|
|
func (mock *Device) GpmSampleGetCalls() []struct {
|
|
GpmSample nvml.GpmSample
|
|
} {
|
|
var calls []struct {
|
|
GpmSample nvml.GpmSample
|
|
}
|
|
mock.lockGpmSampleGet.RLock()
|
|
calls = mock.calls.GpmSampleGet
|
|
mock.lockGpmSampleGet.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// IsMigDeviceHandle calls IsMigDeviceHandleFunc.
|
|
func (mock *Device) IsMigDeviceHandle() (bool, nvml.Return) {
|
|
if mock.IsMigDeviceHandleFunc == nil {
|
|
panic("Device.IsMigDeviceHandleFunc: method is nil but Device.IsMigDeviceHandle was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockIsMigDeviceHandle.Lock()
|
|
mock.calls.IsMigDeviceHandle = append(mock.calls.IsMigDeviceHandle, callInfo)
|
|
mock.lockIsMigDeviceHandle.Unlock()
|
|
return mock.IsMigDeviceHandleFunc()
|
|
}
|
|
|
|
// IsMigDeviceHandleCalls gets all the calls that were made to IsMigDeviceHandle.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.IsMigDeviceHandleCalls())
|
|
func (mock *Device) IsMigDeviceHandleCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockIsMigDeviceHandle.RLock()
|
|
calls = mock.calls.IsMigDeviceHandle
|
|
mock.lockIsMigDeviceHandle.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// OnSameBoard calls OnSameBoardFunc.
|
|
func (mock *Device) OnSameBoard(device nvml.Device) (int, nvml.Return) {
|
|
if mock.OnSameBoardFunc == nil {
|
|
panic("Device.OnSameBoardFunc: method is nil but Device.OnSameBoard was just called")
|
|
}
|
|
callInfo := struct {
|
|
Device nvml.Device
|
|
}{
|
|
Device: device,
|
|
}
|
|
mock.lockOnSameBoard.Lock()
|
|
mock.calls.OnSameBoard = append(mock.calls.OnSameBoard, callInfo)
|
|
mock.lockOnSameBoard.Unlock()
|
|
return mock.OnSameBoardFunc(device)
|
|
}
|
|
|
|
// OnSameBoardCalls gets all the calls that were made to OnSameBoard.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.OnSameBoardCalls())
|
|
func (mock *Device) OnSameBoardCalls() []struct {
|
|
Device nvml.Device
|
|
} {
|
|
var calls []struct {
|
|
Device nvml.Device
|
|
}
|
|
mock.lockOnSameBoard.RLock()
|
|
calls = mock.calls.OnSameBoard
|
|
mock.lockOnSameBoard.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// RegisterEvents calls RegisterEventsFunc.
|
|
func (mock *Device) RegisterEvents(v uint64, eventSet nvml.EventSet) nvml.Return {
|
|
if mock.RegisterEventsFunc == nil {
|
|
panic("Device.RegisterEventsFunc: method is nil but Device.RegisterEvents was just called")
|
|
}
|
|
callInfo := struct {
|
|
V uint64
|
|
EventSet nvml.EventSet
|
|
}{
|
|
V: v,
|
|
EventSet: eventSet,
|
|
}
|
|
mock.lockRegisterEvents.Lock()
|
|
mock.calls.RegisterEvents = append(mock.calls.RegisterEvents, callInfo)
|
|
mock.lockRegisterEvents.Unlock()
|
|
return mock.RegisterEventsFunc(v, eventSet)
|
|
}
|
|
|
|
// RegisterEventsCalls gets all the calls that were made to RegisterEvents.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.RegisterEventsCalls())
|
|
func (mock *Device) RegisterEventsCalls() []struct {
|
|
V uint64
|
|
EventSet nvml.EventSet
|
|
} {
|
|
var calls []struct {
|
|
V uint64
|
|
EventSet nvml.EventSet
|
|
}
|
|
mock.lockRegisterEvents.RLock()
|
|
calls = mock.calls.RegisterEvents
|
|
mock.lockRegisterEvents.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// ResetApplicationsClocks calls ResetApplicationsClocksFunc.
|
|
func (mock *Device) ResetApplicationsClocks() nvml.Return {
|
|
if mock.ResetApplicationsClocksFunc == nil {
|
|
panic("Device.ResetApplicationsClocksFunc: method is nil but Device.ResetApplicationsClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockResetApplicationsClocks.Lock()
|
|
mock.calls.ResetApplicationsClocks = append(mock.calls.ResetApplicationsClocks, callInfo)
|
|
mock.lockResetApplicationsClocks.Unlock()
|
|
return mock.ResetApplicationsClocksFunc()
|
|
}
|
|
|
|
// ResetApplicationsClocksCalls gets all the calls that were made to ResetApplicationsClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.ResetApplicationsClocksCalls())
|
|
func (mock *Device) ResetApplicationsClocksCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockResetApplicationsClocks.RLock()
|
|
calls = mock.calls.ResetApplicationsClocks
|
|
mock.lockResetApplicationsClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// ResetGpuLockedClocks calls ResetGpuLockedClocksFunc.
|
|
func (mock *Device) ResetGpuLockedClocks() nvml.Return {
|
|
if mock.ResetGpuLockedClocksFunc == nil {
|
|
panic("Device.ResetGpuLockedClocksFunc: method is nil but Device.ResetGpuLockedClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockResetGpuLockedClocks.Lock()
|
|
mock.calls.ResetGpuLockedClocks = append(mock.calls.ResetGpuLockedClocks, callInfo)
|
|
mock.lockResetGpuLockedClocks.Unlock()
|
|
return mock.ResetGpuLockedClocksFunc()
|
|
}
|
|
|
|
// ResetGpuLockedClocksCalls gets all the calls that were made to ResetGpuLockedClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.ResetGpuLockedClocksCalls())
|
|
func (mock *Device) ResetGpuLockedClocksCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockResetGpuLockedClocks.RLock()
|
|
calls = mock.calls.ResetGpuLockedClocks
|
|
mock.lockResetGpuLockedClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// ResetMemoryLockedClocks calls ResetMemoryLockedClocksFunc.
|
|
func (mock *Device) ResetMemoryLockedClocks() nvml.Return {
|
|
if mock.ResetMemoryLockedClocksFunc == nil {
|
|
panic("Device.ResetMemoryLockedClocksFunc: method is nil but Device.ResetMemoryLockedClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockResetMemoryLockedClocks.Lock()
|
|
mock.calls.ResetMemoryLockedClocks = append(mock.calls.ResetMemoryLockedClocks, callInfo)
|
|
mock.lockResetMemoryLockedClocks.Unlock()
|
|
return mock.ResetMemoryLockedClocksFunc()
|
|
}
|
|
|
|
// ResetMemoryLockedClocksCalls gets all the calls that were made to ResetMemoryLockedClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.ResetMemoryLockedClocksCalls())
|
|
func (mock *Device) ResetMemoryLockedClocksCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockResetMemoryLockedClocks.RLock()
|
|
calls = mock.calls.ResetMemoryLockedClocks
|
|
mock.lockResetMemoryLockedClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// ResetNvLinkErrorCounters calls ResetNvLinkErrorCountersFunc.
|
|
func (mock *Device) ResetNvLinkErrorCounters(n int) nvml.Return {
|
|
if mock.ResetNvLinkErrorCountersFunc == nil {
|
|
panic("Device.ResetNvLinkErrorCountersFunc: method is nil but Device.ResetNvLinkErrorCounters was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockResetNvLinkErrorCounters.Lock()
|
|
mock.calls.ResetNvLinkErrorCounters = append(mock.calls.ResetNvLinkErrorCounters, callInfo)
|
|
mock.lockResetNvLinkErrorCounters.Unlock()
|
|
return mock.ResetNvLinkErrorCountersFunc(n)
|
|
}
|
|
|
|
// ResetNvLinkErrorCountersCalls gets all the calls that were made to ResetNvLinkErrorCounters.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.ResetNvLinkErrorCountersCalls())
|
|
func (mock *Device) ResetNvLinkErrorCountersCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockResetNvLinkErrorCounters.RLock()
|
|
calls = mock.calls.ResetNvLinkErrorCounters
|
|
mock.lockResetNvLinkErrorCounters.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// ResetNvLinkUtilizationCounter calls ResetNvLinkUtilizationCounterFunc.
|
|
func (mock *Device) ResetNvLinkUtilizationCounter(n1 int, n2 int) nvml.Return {
|
|
if mock.ResetNvLinkUtilizationCounterFunc == nil {
|
|
panic("Device.ResetNvLinkUtilizationCounterFunc: method is nil but Device.ResetNvLinkUtilizationCounter was just called")
|
|
}
|
|
callInfo := struct {
|
|
N1 int
|
|
N2 int
|
|
}{
|
|
N1: n1,
|
|
N2: n2,
|
|
}
|
|
mock.lockResetNvLinkUtilizationCounter.Lock()
|
|
mock.calls.ResetNvLinkUtilizationCounter = append(mock.calls.ResetNvLinkUtilizationCounter, callInfo)
|
|
mock.lockResetNvLinkUtilizationCounter.Unlock()
|
|
return mock.ResetNvLinkUtilizationCounterFunc(n1, n2)
|
|
}
|
|
|
|
// ResetNvLinkUtilizationCounterCalls gets all the calls that were made to ResetNvLinkUtilizationCounter.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.ResetNvLinkUtilizationCounterCalls())
|
|
func (mock *Device) ResetNvLinkUtilizationCounterCalls() []struct {
|
|
N1 int
|
|
N2 int
|
|
} {
|
|
var calls []struct {
|
|
N1 int
|
|
N2 int
|
|
}
|
|
mock.lockResetNvLinkUtilizationCounter.RLock()
|
|
calls = mock.calls.ResetNvLinkUtilizationCounter
|
|
mock.lockResetNvLinkUtilizationCounter.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetAPIRestriction calls SetAPIRestrictionFunc.
|
|
func (mock *Device) SetAPIRestriction(restrictedAPI nvml.RestrictedAPI, enableState nvml.EnableState) nvml.Return {
|
|
if mock.SetAPIRestrictionFunc == nil {
|
|
panic("Device.SetAPIRestrictionFunc: method is nil but Device.SetAPIRestriction was just called")
|
|
}
|
|
callInfo := struct {
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
EnableState nvml.EnableState
|
|
}{
|
|
RestrictedAPI: restrictedAPI,
|
|
EnableState: enableState,
|
|
}
|
|
mock.lockSetAPIRestriction.Lock()
|
|
mock.calls.SetAPIRestriction = append(mock.calls.SetAPIRestriction, callInfo)
|
|
mock.lockSetAPIRestriction.Unlock()
|
|
return mock.SetAPIRestrictionFunc(restrictedAPI, enableState)
|
|
}
|
|
|
|
// SetAPIRestrictionCalls gets all the calls that were made to SetAPIRestriction.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetAPIRestrictionCalls())
|
|
func (mock *Device) SetAPIRestrictionCalls() []struct {
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
EnableState nvml.EnableState
|
|
} {
|
|
var calls []struct {
|
|
RestrictedAPI nvml.RestrictedAPI
|
|
EnableState nvml.EnableState
|
|
}
|
|
mock.lockSetAPIRestriction.RLock()
|
|
calls = mock.calls.SetAPIRestriction
|
|
mock.lockSetAPIRestriction.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetAccountingMode calls SetAccountingModeFunc.
|
|
func (mock *Device) SetAccountingMode(enableState nvml.EnableState) nvml.Return {
|
|
if mock.SetAccountingModeFunc == nil {
|
|
panic("Device.SetAccountingModeFunc: method is nil but Device.SetAccountingMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
EnableState nvml.EnableState
|
|
}{
|
|
EnableState: enableState,
|
|
}
|
|
mock.lockSetAccountingMode.Lock()
|
|
mock.calls.SetAccountingMode = append(mock.calls.SetAccountingMode, callInfo)
|
|
mock.lockSetAccountingMode.Unlock()
|
|
return mock.SetAccountingModeFunc(enableState)
|
|
}
|
|
|
|
// SetAccountingModeCalls gets all the calls that were made to SetAccountingMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetAccountingModeCalls())
|
|
func (mock *Device) SetAccountingModeCalls() []struct {
|
|
EnableState nvml.EnableState
|
|
} {
|
|
var calls []struct {
|
|
EnableState nvml.EnableState
|
|
}
|
|
mock.lockSetAccountingMode.RLock()
|
|
calls = mock.calls.SetAccountingMode
|
|
mock.lockSetAccountingMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetApplicationsClocks calls SetApplicationsClocksFunc.
|
|
func (mock *Device) SetApplicationsClocks(v1 uint32, v2 uint32) nvml.Return {
|
|
if mock.SetApplicationsClocksFunc == nil {
|
|
panic("Device.SetApplicationsClocksFunc: method is nil but Device.SetApplicationsClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
V1 uint32
|
|
V2 uint32
|
|
}{
|
|
V1: v1,
|
|
V2: v2,
|
|
}
|
|
mock.lockSetApplicationsClocks.Lock()
|
|
mock.calls.SetApplicationsClocks = append(mock.calls.SetApplicationsClocks, callInfo)
|
|
mock.lockSetApplicationsClocks.Unlock()
|
|
return mock.SetApplicationsClocksFunc(v1, v2)
|
|
}
|
|
|
|
// SetApplicationsClocksCalls gets all the calls that were made to SetApplicationsClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetApplicationsClocksCalls())
|
|
func (mock *Device) SetApplicationsClocksCalls() []struct {
|
|
V1 uint32
|
|
V2 uint32
|
|
} {
|
|
var calls []struct {
|
|
V1 uint32
|
|
V2 uint32
|
|
}
|
|
mock.lockSetApplicationsClocks.RLock()
|
|
calls = mock.calls.SetApplicationsClocks
|
|
mock.lockSetApplicationsClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetAutoBoostedClocksEnabled calls SetAutoBoostedClocksEnabledFunc.
|
|
func (mock *Device) SetAutoBoostedClocksEnabled(enableState nvml.EnableState) nvml.Return {
|
|
if mock.SetAutoBoostedClocksEnabledFunc == nil {
|
|
panic("Device.SetAutoBoostedClocksEnabledFunc: method is nil but Device.SetAutoBoostedClocksEnabled was just called")
|
|
}
|
|
callInfo := struct {
|
|
EnableState nvml.EnableState
|
|
}{
|
|
EnableState: enableState,
|
|
}
|
|
mock.lockSetAutoBoostedClocksEnabled.Lock()
|
|
mock.calls.SetAutoBoostedClocksEnabled = append(mock.calls.SetAutoBoostedClocksEnabled, callInfo)
|
|
mock.lockSetAutoBoostedClocksEnabled.Unlock()
|
|
return mock.SetAutoBoostedClocksEnabledFunc(enableState)
|
|
}
|
|
|
|
// SetAutoBoostedClocksEnabledCalls gets all the calls that were made to SetAutoBoostedClocksEnabled.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetAutoBoostedClocksEnabledCalls())
|
|
func (mock *Device) SetAutoBoostedClocksEnabledCalls() []struct {
|
|
EnableState nvml.EnableState
|
|
} {
|
|
var calls []struct {
|
|
EnableState nvml.EnableState
|
|
}
|
|
mock.lockSetAutoBoostedClocksEnabled.RLock()
|
|
calls = mock.calls.SetAutoBoostedClocksEnabled
|
|
mock.lockSetAutoBoostedClocksEnabled.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetComputeMode calls SetComputeModeFunc.
|
|
func (mock *Device) SetComputeMode(computeMode nvml.ComputeMode) nvml.Return {
|
|
if mock.SetComputeModeFunc == nil {
|
|
panic("Device.SetComputeModeFunc: method is nil but Device.SetComputeMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
ComputeMode nvml.ComputeMode
|
|
}{
|
|
ComputeMode: computeMode,
|
|
}
|
|
mock.lockSetComputeMode.Lock()
|
|
mock.calls.SetComputeMode = append(mock.calls.SetComputeMode, callInfo)
|
|
mock.lockSetComputeMode.Unlock()
|
|
return mock.SetComputeModeFunc(computeMode)
|
|
}
|
|
|
|
// SetComputeModeCalls gets all the calls that were made to SetComputeMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetComputeModeCalls())
|
|
func (mock *Device) SetComputeModeCalls() []struct {
|
|
ComputeMode nvml.ComputeMode
|
|
} {
|
|
var calls []struct {
|
|
ComputeMode nvml.ComputeMode
|
|
}
|
|
mock.lockSetComputeMode.RLock()
|
|
calls = mock.calls.SetComputeMode
|
|
mock.lockSetComputeMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetCpuAffinity calls SetCpuAffinityFunc.
|
|
func (mock *Device) SetCpuAffinity() nvml.Return {
|
|
if mock.SetCpuAffinityFunc == nil {
|
|
panic("Device.SetCpuAffinityFunc: method is nil but Device.SetCpuAffinity was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockSetCpuAffinity.Lock()
|
|
mock.calls.SetCpuAffinity = append(mock.calls.SetCpuAffinity, callInfo)
|
|
mock.lockSetCpuAffinity.Unlock()
|
|
return mock.SetCpuAffinityFunc()
|
|
}
|
|
|
|
// SetCpuAffinityCalls gets all the calls that were made to SetCpuAffinity.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetCpuAffinityCalls())
|
|
func (mock *Device) SetCpuAffinityCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockSetCpuAffinity.RLock()
|
|
calls = mock.calls.SetCpuAffinity
|
|
mock.lockSetCpuAffinity.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetDefaultAutoBoostedClocksEnabled calls SetDefaultAutoBoostedClocksEnabledFunc.
|
|
func (mock *Device) SetDefaultAutoBoostedClocksEnabled(enableState nvml.EnableState, v uint32) nvml.Return {
|
|
if mock.SetDefaultAutoBoostedClocksEnabledFunc == nil {
|
|
panic("Device.SetDefaultAutoBoostedClocksEnabledFunc: method is nil but Device.SetDefaultAutoBoostedClocksEnabled was just called")
|
|
}
|
|
callInfo := struct {
|
|
EnableState nvml.EnableState
|
|
V uint32
|
|
}{
|
|
EnableState: enableState,
|
|
V: v,
|
|
}
|
|
mock.lockSetDefaultAutoBoostedClocksEnabled.Lock()
|
|
mock.calls.SetDefaultAutoBoostedClocksEnabled = append(mock.calls.SetDefaultAutoBoostedClocksEnabled, callInfo)
|
|
mock.lockSetDefaultAutoBoostedClocksEnabled.Unlock()
|
|
return mock.SetDefaultAutoBoostedClocksEnabledFunc(enableState, v)
|
|
}
|
|
|
|
// SetDefaultAutoBoostedClocksEnabledCalls gets all the calls that were made to SetDefaultAutoBoostedClocksEnabled.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetDefaultAutoBoostedClocksEnabledCalls())
|
|
func (mock *Device) SetDefaultAutoBoostedClocksEnabledCalls() []struct {
|
|
EnableState nvml.EnableState
|
|
V uint32
|
|
} {
|
|
var calls []struct {
|
|
EnableState nvml.EnableState
|
|
V uint32
|
|
}
|
|
mock.lockSetDefaultAutoBoostedClocksEnabled.RLock()
|
|
calls = mock.calls.SetDefaultAutoBoostedClocksEnabled
|
|
mock.lockSetDefaultAutoBoostedClocksEnabled.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetDefaultFanSpeed_v2 calls SetDefaultFanSpeed_v2Func.
|
|
func (mock *Device) SetDefaultFanSpeed_v2(n int) nvml.Return {
|
|
if mock.SetDefaultFanSpeed_v2Func == nil {
|
|
panic("Device.SetDefaultFanSpeed_v2Func: method is nil but Device.SetDefaultFanSpeed_v2 was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockSetDefaultFanSpeed_v2.Lock()
|
|
mock.calls.SetDefaultFanSpeed_v2 = append(mock.calls.SetDefaultFanSpeed_v2, callInfo)
|
|
mock.lockSetDefaultFanSpeed_v2.Unlock()
|
|
return mock.SetDefaultFanSpeed_v2Func(n)
|
|
}
|
|
|
|
// SetDefaultFanSpeed_v2Calls gets all the calls that were made to SetDefaultFanSpeed_v2.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetDefaultFanSpeed_v2Calls())
|
|
func (mock *Device) SetDefaultFanSpeed_v2Calls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockSetDefaultFanSpeed_v2.RLock()
|
|
calls = mock.calls.SetDefaultFanSpeed_v2
|
|
mock.lockSetDefaultFanSpeed_v2.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetDriverModel calls SetDriverModelFunc.
|
|
func (mock *Device) SetDriverModel(driverModel nvml.DriverModel, v uint32) nvml.Return {
|
|
if mock.SetDriverModelFunc == nil {
|
|
panic("Device.SetDriverModelFunc: method is nil but Device.SetDriverModel was just called")
|
|
}
|
|
callInfo := struct {
|
|
DriverModel nvml.DriverModel
|
|
V uint32
|
|
}{
|
|
DriverModel: driverModel,
|
|
V: v,
|
|
}
|
|
mock.lockSetDriverModel.Lock()
|
|
mock.calls.SetDriverModel = append(mock.calls.SetDriverModel, callInfo)
|
|
mock.lockSetDriverModel.Unlock()
|
|
return mock.SetDriverModelFunc(driverModel, v)
|
|
}
|
|
|
|
// SetDriverModelCalls gets all the calls that were made to SetDriverModel.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetDriverModelCalls())
|
|
func (mock *Device) SetDriverModelCalls() []struct {
|
|
DriverModel nvml.DriverModel
|
|
V uint32
|
|
} {
|
|
var calls []struct {
|
|
DriverModel nvml.DriverModel
|
|
V uint32
|
|
}
|
|
mock.lockSetDriverModel.RLock()
|
|
calls = mock.calls.SetDriverModel
|
|
mock.lockSetDriverModel.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetEccMode calls SetEccModeFunc.
|
|
func (mock *Device) SetEccMode(enableState nvml.EnableState) nvml.Return {
|
|
if mock.SetEccModeFunc == nil {
|
|
panic("Device.SetEccModeFunc: method is nil but Device.SetEccMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
EnableState nvml.EnableState
|
|
}{
|
|
EnableState: enableState,
|
|
}
|
|
mock.lockSetEccMode.Lock()
|
|
mock.calls.SetEccMode = append(mock.calls.SetEccMode, callInfo)
|
|
mock.lockSetEccMode.Unlock()
|
|
return mock.SetEccModeFunc(enableState)
|
|
}
|
|
|
|
// SetEccModeCalls gets all the calls that were made to SetEccMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetEccModeCalls())
|
|
func (mock *Device) SetEccModeCalls() []struct {
|
|
EnableState nvml.EnableState
|
|
} {
|
|
var calls []struct {
|
|
EnableState nvml.EnableState
|
|
}
|
|
mock.lockSetEccMode.RLock()
|
|
calls = mock.calls.SetEccMode
|
|
mock.lockSetEccMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetFanControlPolicy calls SetFanControlPolicyFunc.
|
|
func (mock *Device) SetFanControlPolicy(n int, fanControlPolicy nvml.FanControlPolicy) nvml.Return {
|
|
if mock.SetFanControlPolicyFunc == nil {
|
|
panic("Device.SetFanControlPolicyFunc: method is nil but Device.SetFanControlPolicy was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
FanControlPolicy nvml.FanControlPolicy
|
|
}{
|
|
N: n,
|
|
FanControlPolicy: fanControlPolicy,
|
|
}
|
|
mock.lockSetFanControlPolicy.Lock()
|
|
mock.calls.SetFanControlPolicy = append(mock.calls.SetFanControlPolicy, callInfo)
|
|
mock.lockSetFanControlPolicy.Unlock()
|
|
return mock.SetFanControlPolicyFunc(n, fanControlPolicy)
|
|
}
|
|
|
|
// SetFanControlPolicyCalls gets all the calls that were made to SetFanControlPolicy.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetFanControlPolicyCalls())
|
|
func (mock *Device) SetFanControlPolicyCalls() []struct {
|
|
N int
|
|
FanControlPolicy nvml.FanControlPolicy
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
FanControlPolicy nvml.FanControlPolicy
|
|
}
|
|
mock.lockSetFanControlPolicy.RLock()
|
|
calls = mock.calls.SetFanControlPolicy
|
|
mock.lockSetFanControlPolicy.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetFanSpeed_v2 calls SetFanSpeed_v2Func.
|
|
func (mock *Device) SetFanSpeed_v2(n1 int, n2 int) nvml.Return {
|
|
if mock.SetFanSpeed_v2Func == nil {
|
|
panic("Device.SetFanSpeed_v2Func: method is nil but Device.SetFanSpeed_v2 was just called")
|
|
}
|
|
callInfo := struct {
|
|
N1 int
|
|
N2 int
|
|
}{
|
|
N1: n1,
|
|
N2: n2,
|
|
}
|
|
mock.lockSetFanSpeed_v2.Lock()
|
|
mock.calls.SetFanSpeed_v2 = append(mock.calls.SetFanSpeed_v2, callInfo)
|
|
mock.lockSetFanSpeed_v2.Unlock()
|
|
return mock.SetFanSpeed_v2Func(n1, n2)
|
|
}
|
|
|
|
// SetFanSpeed_v2Calls gets all the calls that were made to SetFanSpeed_v2.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetFanSpeed_v2Calls())
|
|
func (mock *Device) SetFanSpeed_v2Calls() []struct {
|
|
N1 int
|
|
N2 int
|
|
} {
|
|
var calls []struct {
|
|
N1 int
|
|
N2 int
|
|
}
|
|
mock.lockSetFanSpeed_v2.RLock()
|
|
calls = mock.calls.SetFanSpeed_v2
|
|
mock.lockSetFanSpeed_v2.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetGpcClkVfOffset calls SetGpcClkVfOffsetFunc.
|
|
func (mock *Device) SetGpcClkVfOffset(n int) nvml.Return {
|
|
if mock.SetGpcClkVfOffsetFunc == nil {
|
|
panic("Device.SetGpcClkVfOffsetFunc: method is nil but Device.SetGpcClkVfOffset was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockSetGpcClkVfOffset.Lock()
|
|
mock.calls.SetGpcClkVfOffset = append(mock.calls.SetGpcClkVfOffset, callInfo)
|
|
mock.lockSetGpcClkVfOffset.Unlock()
|
|
return mock.SetGpcClkVfOffsetFunc(n)
|
|
}
|
|
|
|
// SetGpcClkVfOffsetCalls gets all the calls that were made to SetGpcClkVfOffset.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetGpcClkVfOffsetCalls())
|
|
func (mock *Device) SetGpcClkVfOffsetCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockSetGpcClkVfOffset.RLock()
|
|
calls = mock.calls.SetGpcClkVfOffset
|
|
mock.lockSetGpcClkVfOffset.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetGpuLockedClocks calls SetGpuLockedClocksFunc.
|
|
func (mock *Device) SetGpuLockedClocks(v1 uint32, v2 uint32) nvml.Return {
|
|
if mock.SetGpuLockedClocksFunc == nil {
|
|
panic("Device.SetGpuLockedClocksFunc: method is nil but Device.SetGpuLockedClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
V1 uint32
|
|
V2 uint32
|
|
}{
|
|
V1: v1,
|
|
V2: v2,
|
|
}
|
|
mock.lockSetGpuLockedClocks.Lock()
|
|
mock.calls.SetGpuLockedClocks = append(mock.calls.SetGpuLockedClocks, callInfo)
|
|
mock.lockSetGpuLockedClocks.Unlock()
|
|
return mock.SetGpuLockedClocksFunc(v1, v2)
|
|
}
|
|
|
|
// SetGpuLockedClocksCalls gets all the calls that were made to SetGpuLockedClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetGpuLockedClocksCalls())
|
|
func (mock *Device) SetGpuLockedClocksCalls() []struct {
|
|
V1 uint32
|
|
V2 uint32
|
|
} {
|
|
var calls []struct {
|
|
V1 uint32
|
|
V2 uint32
|
|
}
|
|
mock.lockSetGpuLockedClocks.RLock()
|
|
calls = mock.calls.SetGpuLockedClocks
|
|
mock.lockSetGpuLockedClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetGpuOperationMode calls SetGpuOperationModeFunc.
|
|
func (mock *Device) SetGpuOperationMode(gpuOperationMode nvml.GpuOperationMode) nvml.Return {
|
|
if mock.SetGpuOperationModeFunc == nil {
|
|
panic("Device.SetGpuOperationModeFunc: method is nil but Device.SetGpuOperationMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuOperationMode nvml.GpuOperationMode
|
|
}{
|
|
GpuOperationMode: gpuOperationMode,
|
|
}
|
|
mock.lockSetGpuOperationMode.Lock()
|
|
mock.calls.SetGpuOperationMode = append(mock.calls.SetGpuOperationMode, callInfo)
|
|
mock.lockSetGpuOperationMode.Unlock()
|
|
return mock.SetGpuOperationModeFunc(gpuOperationMode)
|
|
}
|
|
|
|
// SetGpuOperationModeCalls gets all the calls that were made to SetGpuOperationMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetGpuOperationModeCalls())
|
|
func (mock *Device) SetGpuOperationModeCalls() []struct {
|
|
GpuOperationMode nvml.GpuOperationMode
|
|
} {
|
|
var calls []struct {
|
|
GpuOperationMode nvml.GpuOperationMode
|
|
}
|
|
mock.lockSetGpuOperationMode.RLock()
|
|
calls = mock.calls.SetGpuOperationMode
|
|
mock.lockSetGpuOperationMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetMemClkVfOffset calls SetMemClkVfOffsetFunc.
|
|
func (mock *Device) SetMemClkVfOffset(n int) nvml.Return {
|
|
if mock.SetMemClkVfOffsetFunc == nil {
|
|
panic("Device.SetMemClkVfOffsetFunc: method is nil but Device.SetMemClkVfOffset was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockSetMemClkVfOffset.Lock()
|
|
mock.calls.SetMemClkVfOffset = append(mock.calls.SetMemClkVfOffset, callInfo)
|
|
mock.lockSetMemClkVfOffset.Unlock()
|
|
return mock.SetMemClkVfOffsetFunc(n)
|
|
}
|
|
|
|
// SetMemClkVfOffsetCalls gets all the calls that were made to SetMemClkVfOffset.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetMemClkVfOffsetCalls())
|
|
func (mock *Device) SetMemClkVfOffsetCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockSetMemClkVfOffset.RLock()
|
|
calls = mock.calls.SetMemClkVfOffset
|
|
mock.lockSetMemClkVfOffset.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetMemoryLockedClocks calls SetMemoryLockedClocksFunc.
|
|
func (mock *Device) SetMemoryLockedClocks(v1 uint32, v2 uint32) nvml.Return {
|
|
if mock.SetMemoryLockedClocksFunc == nil {
|
|
panic("Device.SetMemoryLockedClocksFunc: method is nil but Device.SetMemoryLockedClocks was just called")
|
|
}
|
|
callInfo := struct {
|
|
V1 uint32
|
|
V2 uint32
|
|
}{
|
|
V1: v1,
|
|
V2: v2,
|
|
}
|
|
mock.lockSetMemoryLockedClocks.Lock()
|
|
mock.calls.SetMemoryLockedClocks = append(mock.calls.SetMemoryLockedClocks, callInfo)
|
|
mock.lockSetMemoryLockedClocks.Unlock()
|
|
return mock.SetMemoryLockedClocksFunc(v1, v2)
|
|
}
|
|
|
|
// SetMemoryLockedClocksCalls gets all the calls that were made to SetMemoryLockedClocks.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetMemoryLockedClocksCalls())
|
|
func (mock *Device) SetMemoryLockedClocksCalls() []struct {
|
|
V1 uint32
|
|
V2 uint32
|
|
} {
|
|
var calls []struct {
|
|
V1 uint32
|
|
V2 uint32
|
|
}
|
|
mock.lockSetMemoryLockedClocks.RLock()
|
|
calls = mock.calls.SetMemoryLockedClocks
|
|
mock.lockSetMemoryLockedClocks.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetMigMode calls SetMigModeFunc.
|
|
func (mock *Device) SetMigMode(n int) (nvml.Return, nvml.Return) {
|
|
if mock.SetMigModeFunc == nil {
|
|
panic("Device.SetMigModeFunc: method is nil but Device.SetMigMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
N int
|
|
}{
|
|
N: n,
|
|
}
|
|
mock.lockSetMigMode.Lock()
|
|
mock.calls.SetMigMode = append(mock.calls.SetMigMode, callInfo)
|
|
mock.lockSetMigMode.Unlock()
|
|
return mock.SetMigModeFunc(n)
|
|
}
|
|
|
|
// SetMigModeCalls gets all the calls that were made to SetMigMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetMigModeCalls())
|
|
func (mock *Device) SetMigModeCalls() []struct {
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
N int
|
|
}
|
|
mock.lockSetMigMode.RLock()
|
|
calls = mock.calls.SetMigMode
|
|
mock.lockSetMigMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetNvLinkDeviceLowPowerThreshold calls SetNvLinkDeviceLowPowerThresholdFunc.
|
|
func (mock *Device) SetNvLinkDeviceLowPowerThreshold(nvLinkPowerThres *nvml.NvLinkPowerThres) nvml.Return {
|
|
if mock.SetNvLinkDeviceLowPowerThresholdFunc == nil {
|
|
panic("Device.SetNvLinkDeviceLowPowerThresholdFunc: method is nil but Device.SetNvLinkDeviceLowPowerThreshold was just called")
|
|
}
|
|
callInfo := struct {
|
|
NvLinkPowerThres *nvml.NvLinkPowerThres
|
|
}{
|
|
NvLinkPowerThres: nvLinkPowerThres,
|
|
}
|
|
mock.lockSetNvLinkDeviceLowPowerThreshold.Lock()
|
|
mock.calls.SetNvLinkDeviceLowPowerThreshold = append(mock.calls.SetNvLinkDeviceLowPowerThreshold, callInfo)
|
|
mock.lockSetNvLinkDeviceLowPowerThreshold.Unlock()
|
|
return mock.SetNvLinkDeviceLowPowerThresholdFunc(nvLinkPowerThres)
|
|
}
|
|
|
|
// SetNvLinkDeviceLowPowerThresholdCalls gets all the calls that were made to SetNvLinkDeviceLowPowerThreshold.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetNvLinkDeviceLowPowerThresholdCalls())
|
|
func (mock *Device) SetNvLinkDeviceLowPowerThresholdCalls() []struct {
|
|
NvLinkPowerThres *nvml.NvLinkPowerThres
|
|
} {
|
|
var calls []struct {
|
|
NvLinkPowerThres *nvml.NvLinkPowerThres
|
|
}
|
|
mock.lockSetNvLinkDeviceLowPowerThreshold.RLock()
|
|
calls = mock.calls.SetNvLinkDeviceLowPowerThreshold
|
|
mock.lockSetNvLinkDeviceLowPowerThreshold.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetNvLinkUtilizationControl calls SetNvLinkUtilizationControlFunc.
|
|
func (mock *Device) SetNvLinkUtilizationControl(n1 int, n2 int, nvLinkUtilizationControl *nvml.NvLinkUtilizationControl, b bool) nvml.Return {
|
|
if mock.SetNvLinkUtilizationControlFunc == nil {
|
|
panic("Device.SetNvLinkUtilizationControlFunc: method is nil but Device.SetNvLinkUtilizationControl was just called")
|
|
}
|
|
callInfo := struct {
|
|
N1 int
|
|
N2 int
|
|
NvLinkUtilizationControl *nvml.NvLinkUtilizationControl
|
|
B bool
|
|
}{
|
|
N1: n1,
|
|
N2: n2,
|
|
NvLinkUtilizationControl: nvLinkUtilizationControl,
|
|
B: b,
|
|
}
|
|
mock.lockSetNvLinkUtilizationControl.Lock()
|
|
mock.calls.SetNvLinkUtilizationControl = append(mock.calls.SetNvLinkUtilizationControl, callInfo)
|
|
mock.lockSetNvLinkUtilizationControl.Unlock()
|
|
return mock.SetNvLinkUtilizationControlFunc(n1, n2, nvLinkUtilizationControl, b)
|
|
}
|
|
|
|
// SetNvLinkUtilizationControlCalls gets all the calls that were made to SetNvLinkUtilizationControl.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetNvLinkUtilizationControlCalls())
|
|
func (mock *Device) SetNvLinkUtilizationControlCalls() []struct {
|
|
N1 int
|
|
N2 int
|
|
NvLinkUtilizationControl *nvml.NvLinkUtilizationControl
|
|
B bool
|
|
} {
|
|
var calls []struct {
|
|
N1 int
|
|
N2 int
|
|
NvLinkUtilizationControl *nvml.NvLinkUtilizationControl
|
|
B bool
|
|
}
|
|
mock.lockSetNvLinkUtilizationControl.RLock()
|
|
calls = mock.calls.SetNvLinkUtilizationControl
|
|
mock.lockSetNvLinkUtilizationControl.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetPersistenceMode calls SetPersistenceModeFunc.
|
|
func (mock *Device) SetPersistenceMode(enableState nvml.EnableState) nvml.Return {
|
|
if mock.SetPersistenceModeFunc == nil {
|
|
panic("Device.SetPersistenceModeFunc: method is nil but Device.SetPersistenceMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
EnableState nvml.EnableState
|
|
}{
|
|
EnableState: enableState,
|
|
}
|
|
mock.lockSetPersistenceMode.Lock()
|
|
mock.calls.SetPersistenceMode = append(mock.calls.SetPersistenceMode, callInfo)
|
|
mock.lockSetPersistenceMode.Unlock()
|
|
return mock.SetPersistenceModeFunc(enableState)
|
|
}
|
|
|
|
// SetPersistenceModeCalls gets all the calls that were made to SetPersistenceMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetPersistenceModeCalls())
|
|
func (mock *Device) SetPersistenceModeCalls() []struct {
|
|
EnableState nvml.EnableState
|
|
} {
|
|
var calls []struct {
|
|
EnableState nvml.EnableState
|
|
}
|
|
mock.lockSetPersistenceMode.RLock()
|
|
calls = mock.calls.SetPersistenceMode
|
|
mock.lockSetPersistenceMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetPowerManagementLimit calls SetPowerManagementLimitFunc.
|
|
func (mock *Device) SetPowerManagementLimit(v uint32) nvml.Return {
|
|
if mock.SetPowerManagementLimitFunc == nil {
|
|
panic("Device.SetPowerManagementLimitFunc: method is nil but Device.SetPowerManagementLimit was just called")
|
|
}
|
|
callInfo := struct {
|
|
V uint32
|
|
}{
|
|
V: v,
|
|
}
|
|
mock.lockSetPowerManagementLimit.Lock()
|
|
mock.calls.SetPowerManagementLimit = append(mock.calls.SetPowerManagementLimit, callInfo)
|
|
mock.lockSetPowerManagementLimit.Unlock()
|
|
return mock.SetPowerManagementLimitFunc(v)
|
|
}
|
|
|
|
// SetPowerManagementLimitCalls gets all the calls that were made to SetPowerManagementLimit.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetPowerManagementLimitCalls())
|
|
func (mock *Device) SetPowerManagementLimitCalls() []struct {
|
|
V uint32
|
|
} {
|
|
var calls []struct {
|
|
V uint32
|
|
}
|
|
mock.lockSetPowerManagementLimit.RLock()
|
|
calls = mock.calls.SetPowerManagementLimit
|
|
mock.lockSetPowerManagementLimit.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetTemperatureThreshold calls SetTemperatureThresholdFunc.
|
|
func (mock *Device) SetTemperatureThreshold(temperatureThresholds nvml.TemperatureThresholds, n int) nvml.Return {
|
|
if mock.SetTemperatureThresholdFunc == nil {
|
|
panic("Device.SetTemperatureThresholdFunc: method is nil but Device.SetTemperatureThreshold was just called")
|
|
}
|
|
callInfo := struct {
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
N int
|
|
}{
|
|
TemperatureThresholds: temperatureThresholds,
|
|
N: n,
|
|
}
|
|
mock.lockSetTemperatureThreshold.Lock()
|
|
mock.calls.SetTemperatureThreshold = append(mock.calls.SetTemperatureThreshold, callInfo)
|
|
mock.lockSetTemperatureThreshold.Unlock()
|
|
return mock.SetTemperatureThresholdFunc(temperatureThresholds, n)
|
|
}
|
|
|
|
// SetTemperatureThresholdCalls gets all the calls that were made to SetTemperatureThreshold.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetTemperatureThresholdCalls())
|
|
func (mock *Device) SetTemperatureThresholdCalls() []struct {
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
N int
|
|
} {
|
|
var calls []struct {
|
|
TemperatureThresholds nvml.TemperatureThresholds
|
|
N int
|
|
}
|
|
mock.lockSetTemperatureThreshold.RLock()
|
|
calls = mock.calls.SetTemperatureThreshold
|
|
mock.lockSetTemperatureThreshold.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetVgpuSchedulerState calls SetVgpuSchedulerStateFunc.
|
|
func (mock *Device) SetVgpuSchedulerState(vgpuSchedulerSetState *nvml.VgpuSchedulerSetState) nvml.Return {
|
|
if mock.SetVgpuSchedulerStateFunc == nil {
|
|
panic("Device.SetVgpuSchedulerStateFunc: method is nil but Device.SetVgpuSchedulerState was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
|
|
}{
|
|
VgpuSchedulerSetState: vgpuSchedulerSetState,
|
|
}
|
|
mock.lockSetVgpuSchedulerState.Lock()
|
|
mock.calls.SetVgpuSchedulerState = append(mock.calls.SetVgpuSchedulerState, callInfo)
|
|
mock.lockSetVgpuSchedulerState.Unlock()
|
|
return mock.SetVgpuSchedulerStateFunc(vgpuSchedulerSetState)
|
|
}
|
|
|
|
// SetVgpuSchedulerStateCalls gets all the calls that were made to SetVgpuSchedulerState.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetVgpuSchedulerStateCalls())
|
|
func (mock *Device) SetVgpuSchedulerStateCalls() []struct {
|
|
VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
|
|
} {
|
|
var calls []struct {
|
|
VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
|
|
}
|
|
mock.lockSetVgpuSchedulerState.RLock()
|
|
calls = mock.calls.SetVgpuSchedulerState
|
|
mock.lockSetVgpuSchedulerState.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// SetVirtualizationMode calls SetVirtualizationModeFunc.
|
|
func (mock *Device) SetVirtualizationMode(gpuVirtualizationMode nvml.GpuVirtualizationMode) nvml.Return {
|
|
if mock.SetVirtualizationModeFunc == nil {
|
|
panic("Device.SetVirtualizationModeFunc: method is nil but Device.SetVirtualizationMode was just called")
|
|
}
|
|
callInfo := struct {
|
|
GpuVirtualizationMode nvml.GpuVirtualizationMode
|
|
}{
|
|
GpuVirtualizationMode: gpuVirtualizationMode,
|
|
}
|
|
mock.lockSetVirtualizationMode.Lock()
|
|
mock.calls.SetVirtualizationMode = append(mock.calls.SetVirtualizationMode, callInfo)
|
|
mock.lockSetVirtualizationMode.Unlock()
|
|
return mock.SetVirtualizationModeFunc(gpuVirtualizationMode)
|
|
}
|
|
|
|
// SetVirtualizationModeCalls gets all the calls that were made to SetVirtualizationMode.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.SetVirtualizationModeCalls())
|
|
func (mock *Device) SetVirtualizationModeCalls() []struct {
|
|
GpuVirtualizationMode nvml.GpuVirtualizationMode
|
|
} {
|
|
var calls []struct {
|
|
GpuVirtualizationMode nvml.GpuVirtualizationMode
|
|
}
|
|
mock.lockSetVirtualizationMode.RLock()
|
|
calls = mock.calls.SetVirtualizationMode
|
|
mock.lockSetVirtualizationMode.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// ValidateInforom calls ValidateInforomFunc.
|
|
func (mock *Device) ValidateInforom() nvml.Return {
|
|
if mock.ValidateInforomFunc == nil {
|
|
panic("Device.ValidateInforomFunc: method is nil but Device.ValidateInforom was just called")
|
|
}
|
|
callInfo := struct {
|
|
}{}
|
|
mock.lockValidateInforom.Lock()
|
|
mock.calls.ValidateInforom = append(mock.calls.ValidateInforom, callInfo)
|
|
mock.lockValidateInforom.Unlock()
|
|
return mock.ValidateInforomFunc()
|
|
}
|
|
|
|
// ValidateInforomCalls gets all the calls that were made to ValidateInforom.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.ValidateInforomCalls())
|
|
func (mock *Device) ValidateInforomCalls() []struct {
|
|
} {
|
|
var calls []struct {
|
|
}
|
|
mock.lockValidateInforom.RLock()
|
|
calls = mock.calls.ValidateInforom
|
|
mock.lockValidateInforom.RUnlock()
|
|
return calls
|
|
}
|
|
|
|
// VgpuTypeGetMaxInstances calls VgpuTypeGetMaxInstancesFunc.
|
|
func (mock *Device) VgpuTypeGetMaxInstances(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
|
|
if mock.VgpuTypeGetMaxInstancesFunc == nil {
|
|
panic("Device.VgpuTypeGetMaxInstancesFunc: method is nil but Device.VgpuTypeGetMaxInstances was just called")
|
|
}
|
|
callInfo := struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}{
|
|
VgpuTypeId: vgpuTypeId,
|
|
}
|
|
mock.lockVgpuTypeGetMaxInstances.Lock()
|
|
mock.calls.VgpuTypeGetMaxInstances = append(mock.calls.VgpuTypeGetMaxInstances, callInfo)
|
|
mock.lockVgpuTypeGetMaxInstances.Unlock()
|
|
return mock.VgpuTypeGetMaxInstancesFunc(vgpuTypeId)
|
|
}
|
|
|
|
// VgpuTypeGetMaxInstancesCalls gets all the calls that were made to VgpuTypeGetMaxInstances.
|
|
// Check the length with:
|
|
//
|
|
// len(mockedDevice.VgpuTypeGetMaxInstancesCalls())
|
|
func (mock *Device) VgpuTypeGetMaxInstancesCalls() []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
} {
|
|
var calls []struct {
|
|
VgpuTypeId nvml.VgpuTypeId
|
|
}
|
|
mock.lockVgpuTypeGetMaxInstances.RLock()
|
|
calls = mock.calls.VgpuTypeGetMaxInstances
|
|
mock.lockVgpuTypeGetMaxInstances.RUnlock()
|
|
return calls
|
|
}
|