// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aws/amazon-ecs-agent/ecs-init/gpu (interfaces: GPUDevice)

// Package mock_gpu is a generated GoMock package.
package mock_gpu

import (
	reflect "reflect"

	nvml "github.com/NVIDIA/go-nvml/pkg/nvml"
	gomock "github.com/golang/mock/gomock"
)

// MockGPUDevice is a mock of GPUDevice interface.
type MockGPUDevice struct {
	ctrl     *gomock.Controller
	recorder *MockGPUDeviceMockRecorder
}

// MockGPUDeviceMockRecorder is the mock recorder for MockGPUDevice.
type MockGPUDeviceMockRecorder struct {
	mock *MockGPUDevice
}

// NewMockGPUDevice creates a new mock instance.
func NewMockGPUDevice(ctrl *gomock.Controller) *MockGPUDevice {
	mock := &MockGPUDevice{ctrl: ctrl}
	mock.recorder = &MockGPUDeviceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockGPUDevice) EXPECT() *MockGPUDeviceMockRecorder {
	return m.recorder
}

// ClearAccountingPids mocks base method.
func (m *MockGPUDevice) ClearAccountingPids() nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClearAccountingPids")
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// ClearAccountingPids indicates an expected call of ClearAccountingPids.
func (mr *MockGPUDeviceMockRecorder) ClearAccountingPids() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearAccountingPids", reflect.TypeOf((*MockGPUDevice)(nil).ClearAccountingPids))
}

// ClearCpuAffinity mocks base method.
func (m *MockGPUDevice) ClearCpuAffinity() nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClearCpuAffinity")
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// ClearCpuAffinity indicates an expected call of ClearCpuAffinity.
func (mr *MockGPUDeviceMockRecorder) ClearCpuAffinity() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearCpuAffinity", reflect.TypeOf((*MockGPUDevice)(nil).ClearCpuAffinity))
}

// ClearEccErrorCounts mocks base method.
func (m *MockGPUDevice) ClearEccErrorCounts(arg0 nvml.EccCounterType) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClearEccErrorCounts", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// ClearEccErrorCounts indicates an expected call of ClearEccErrorCounts.
func (mr *MockGPUDeviceMockRecorder) ClearEccErrorCounts(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearEccErrorCounts", reflect.TypeOf((*MockGPUDevice)(nil).ClearEccErrorCounts), arg0)
}

// ClearFieldValues mocks base method.
func (m *MockGPUDevice) ClearFieldValues(arg0 []nvml.FieldValue) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClearFieldValues", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// ClearFieldValues indicates an expected call of ClearFieldValues.
func (mr *MockGPUDeviceMockRecorder) ClearFieldValues(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearFieldValues", reflect.TypeOf((*MockGPUDevice)(nil).ClearFieldValues), arg0)
}

// CreateGpuInstance mocks base method.
func (m *MockGPUDevice) CreateGpuInstance(arg0 *nvml.GpuInstanceProfileInfo) (nvml.GpuInstance, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGpuInstance", arg0)
	ret0, _ := ret[0].(nvml.GpuInstance)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// CreateGpuInstance indicates an expected call of CreateGpuInstance.
func (mr *MockGPUDeviceMockRecorder) CreateGpuInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGpuInstance", reflect.TypeOf((*MockGPUDevice)(nil).CreateGpuInstance), arg0)
}

// CreateGpuInstanceWithPlacement mocks base method.
func (m *MockGPUDevice) CreateGpuInstanceWithPlacement(arg0 *nvml.GpuInstanceProfileInfo, arg1 *nvml.GpuInstancePlacement) (nvml.GpuInstance, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGpuInstanceWithPlacement", arg0, arg1)
	ret0, _ := ret[0].(nvml.GpuInstance)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// CreateGpuInstanceWithPlacement indicates an expected call of CreateGpuInstanceWithPlacement.
func (mr *MockGPUDeviceMockRecorder) CreateGpuInstanceWithPlacement(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGpuInstanceWithPlacement", reflect.TypeOf((*MockGPUDevice)(nil).CreateGpuInstanceWithPlacement), arg0, arg1)
}

// FreezeNvLinkUtilizationCounter mocks base method.
func (m *MockGPUDevice) FreezeNvLinkUtilizationCounter(arg0, arg1 int, arg2 nvml.EnableState) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FreezeNvLinkUtilizationCounter", arg0, arg1, arg2)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// FreezeNvLinkUtilizationCounter indicates an expected call of FreezeNvLinkUtilizationCounter.
func (mr *MockGPUDeviceMockRecorder) FreezeNvLinkUtilizationCounter(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FreezeNvLinkUtilizationCounter", reflect.TypeOf((*MockGPUDevice)(nil).FreezeNvLinkUtilizationCounter), arg0, arg1, arg2)
}

// GetAPIRestriction mocks base method.
func (m *MockGPUDevice) GetAPIRestriction(arg0 nvml.RestrictedAPI) (nvml.EnableState, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAPIRestriction", arg0)
	ret0, _ := ret[0].(nvml.EnableState)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetAPIRestriction indicates an expected call of GetAPIRestriction.
func (mr *MockGPUDeviceMockRecorder) GetAPIRestriction(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAPIRestriction", reflect.TypeOf((*MockGPUDevice)(nil).GetAPIRestriction), arg0)
}

// GetAccountingBufferSize mocks base method.
func (m *MockGPUDevice) GetAccountingBufferSize() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountingBufferSize")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetAccountingBufferSize indicates an expected call of GetAccountingBufferSize.
func (mr *MockGPUDeviceMockRecorder) GetAccountingBufferSize() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountingBufferSize", reflect.TypeOf((*MockGPUDevice)(nil).GetAccountingBufferSize))
}

// GetAccountingMode mocks base method.
func (m *MockGPUDevice) GetAccountingMode() (nvml.EnableState, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountingMode")
	ret0, _ := ret[0].(nvml.EnableState)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetAccountingMode indicates an expected call of GetAccountingMode.
func (mr *MockGPUDeviceMockRecorder) GetAccountingMode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountingMode", reflect.TypeOf((*MockGPUDevice)(nil).GetAccountingMode))
}

// GetAccountingPids mocks base method.
func (m *MockGPUDevice) GetAccountingPids() ([]int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountingPids")
	ret0, _ := ret[0].([]int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetAccountingPids indicates an expected call of GetAccountingPids.
func (mr *MockGPUDeviceMockRecorder) GetAccountingPids() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountingPids", reflect.TypeOf((*MockGPUDevice)(nil).GetAccountingPids))
}

// GetAccountingStats mocks base method.
func (m *MockGPUDevice) GetAccountingStats(arg0 uint32) (nvml.AccountingStats, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountingStats", arg0)
	ret0, _ := ret[0].(nvml.AccountingStats)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetAccountingStats indicates an expected call of GetAccountingStats.
func (mr *MockGPUDeviceMockRecorder) GetAccountingStats(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountingStats", reflect.TypeOf((*MockGPUDevice)(nil).GetAccountingStats), arg0)
}

// GetActiveVgpus mocks base method.
func (m *MockGPUDevice) GetActiveVgpus() ([]nvml.VgpuInstance, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActiveVgpus")
	ret0, _ := ret[0].([]nvml.VgpuInstance)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetActiveVgpus indicates an expected call of GetActiveVgpus.
func (mr *MockGPUDeviceMockRecorder) GetActiveVgpus() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActiveVgpus", reflect.TypeOf((*MockGPUDevice)(nil).GetActiveVgpus))
}

// GetAdaptiveClockInfoStatus mocks base method.
func (m *MockGPUDevice) GetAdaptiveClockInfoStatus() (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAdaptiveClockInfoStatus")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetAdaptiveClockInfoStatus indicates an expected call of GetAdaptiveClockInfoStatus.
func (mr *MockGPUDeviceMockRecorder) GetAdaptiveClockInfoStatus() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAdaptiveClockInfoStatus", reflect.TypeOf((*MockGPUDevice)(nil).GetAdaptiveClockInfoStatus))
}

// GetApplicationsClock mocks base method.
func (m *MockGPUDevice) GetApplicationsClock(arg0 nvml.ClockType) (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetApplicationsClock", arg0)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetApplicationsClock indicates an expected call of GetApplicationsClock.
func (mr *MockGPUDeviceMockRecorder) GetApplicationsClock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetApplicationsClock", reflect.TypeOf((*MockGPUDevice)(nil).GetApplicationsClock), arg0)
}

// GetArchitecture mocks base method.
func (m *MockGPUDevice) GetArchitecture() (nvml.DeviceArchitecture, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetArchitecture")
	ret0, _ := ret[0].(nvml.DeviceArchitecture)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetArchitecture indicates an expected call of GetArchitecture.
func (mr *MockGPUDeviceMockRecorder) GetArchitecture() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArchitecture", reflect.TypeOf((*MockGPUDevice)(nil).GetArchitecture))
}

// GetAttributes mocks base method.
func (m *MockGPUDevice) GetAttributes() (nvml.DeviceAttributes, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAttributes")
	ret0, _ := ret[0].(nvml.DeviceAttributes)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetAttributes indicates an expected call of GetAttributes.
func (mr *MockGPUDeviceMockRecorder) GetAttributes() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttributes", reflect.TypeOf((*MockGPUDevice)(nil).GetAttributes))
}

// GetAutoBoostedClocksEnabled mocks base method.
func (m *MockGPUDevice) GetAutoBoostedClocksEnabled() (nvml.EnableState, nvml.EnableState, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAutoBoostedClocksEnabled")
	ret0, _ := ret[0].(nvml.EnableState)
	ret1, _ := ret[1].(nvml.EnableState)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetAutoBoostedClocksEnabled indicates an expected call of GetAutoBoostedClocksEnabled.
func (mr *MockGPUDeviceMockRecorder) GetAutoBoostedClocksEnabled() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAutoBoostedClocksEnabled", reflect.TypeOf((*MockGPUDevice)(nil).GetAutoBoostedClocksEnabled))
}

// GetBAR1MemoryInfo mocks base method.
func (m *MockGPUDevice) GetBAR1MemoryInfo() (nvml.BAR1Memory, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBAR1MemoryInfo")
	ret0, _ := ret[0].(nvml.BAR1Memory)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetBAR1MemoryInfo indicates an expected call of GetBAR1MemoryInfo.
func (mr *MockGPUDeviceMockRecorder) GetBAR1MemoryInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBAR1MemoryInfo", reflect.TypeOf((*MockGPUDevice)(nil).GetBAR1MemoryInfo))
}

// GetBoardId mocks base method.
func (m *MockGPUDevice) GetBoardId() (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBoardId")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetBoardId indicates an expected call of GetBoardId.
func (mr *MockGPUDeviceMockRecorder) GetBoardId() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBoardId", reflect.TypeOf((*MockGPUDevice)(nil).GetBoardId))
}

// GetBoardPartNumber mocks base method.
func (m *MockGPUDevice) GetBoardPartNumber() (string, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBoardPartNumber")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetBoardPartNumber indicates an expected call of GetBoardPartNumber.
func (mr *MockGPUDeviceMockRecorder) GetBoardPartNumber() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBoardPartNumber", reflect.TypeOf((*MockGPUDevice)(nil).GetBoardPartNumber))
}

// GetBrand mocks base method.
func (m *MockGPUDevice) GetBrand() (nvml.BrandType, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBrand")
	ret0, _ := ret[0].(nvml.BrandType)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetBrand indicates an expected call of GetBrand.
func (mr *MockGPUDeviceMockRecorder) GetBrand() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBrand", reflect.TypeOf((*MockGPUDevice)(nil).GetBrand))
}

// GetBridgeChipInfo mocks base method.
func (m *MockGPUDevice) GetBridgeChipInfo() (nvml.BridgeChipHierarchy, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBridgeChipInfo")
	ret0, _ := ret[0].(nvml.BridgeChipHierarchy)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetBridgeChipInfo indicates an expected call of GetBridgeChipInfo.
func (mr *MockGPUDeviceMockRecorder) GetBridgeChipInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBridgeChipInfo", reflect.TypeOf((*MockGPUDevice)(nil).GetBridgeChipInfo))
}

// GetBusType mocks base method.
func (m *MockGPUDevice) GetBusType() (nvml.BusType, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBusType")
	ret0, _ := ret[0].(nvml.BusType)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetBusType indicates an expected call of GetBusType.
func (mr *MockGPUDeviceMockRecorder) GetBusType() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBusType", reflect.TypeOf((*MockGPUDevice)(nil).GetBusType))
}

// GetC2cModeInfoV mocks base method.
func (m *MockGPUDevice) GetC2cModeInfoV() nvml.C2cModeInfoHandler {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetC2cModeInfoV")
	ret0, _ := ret[0].(nvml.C2cModeInfoHandler)
	return ret0
}

// GetC2cModeInfoV indicates an expected call of GetC2cModeInfoV.
func (mr *MockGPUDeviceMockRecorder) GetC2cModeInfoV() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetC2cModeInfoV", reflect.TypeOf((*MockGPUDevice)(nil).GetC2cModeInfoV))
}

// GetClkMonStatus mocks base method.
func (m *MockGPUDevice) GetClkMonStatus() (nvml.ClkMonStatus, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClkMonStatus")
	ret0, _ := ret[0].(nvml.ClkMonStatus)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetClkMonStatus indicates an expected call of GetClkMonStatus.
func (mr *MockGPUDeviceMockRecorder) GetClkMonStatus() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClkMonStatus", reflect.TypeOf((*MockGPUDevice)(nil).GetClkMonStatus))
}

// GetClock mocks base method.
func (m *MockGPUDevice) GetClock(arg0 nvml.ClockType, arg1 nvml.ClockId) (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClock", arg0, arg1)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetClock indicates an expected call of GetClock.
func (mr *MockGPUDeviceMockRecorder) GetClock(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClock", reflect.TypeOf((*MockGPUDevice)(nil).GetClock), arg0, arg1)
}

// GetClockInfo mocks base method.
func (m *MockGPUDevice) GetClockInfo(arg0 nvml.ClockType) (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClockInfo", arg0)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetClockInfo indicates an expected call of GetClockInfo.
func (mr *MockGPUDeviceMockRecorder) GetClockInfo(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClockInfo", reflect.TypeOf((*MockGPUDevice)(nil).GetClockInfo), arg0)
}

// GetComputeInstanceId mocks base method.
func (m *MockGPUDevice) GetComputeInstanceId() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetComputeInstanceId")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetComputeInstanceId indicates an expected call of GetComputeInstanceId.
func (mr *MockGPUDeviceMockRecorder) GetComputeInstanceId() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComputeInstanceId", reflect.TypeOf((*MockGPUDevice)(nil).GetComputeInstanceId))
}

// GetComputeMode mocks base method.
func (m *MockGPUDevice) GetComputeMode() (nvml.ComputeMode, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetComputeMode")
	ret0, _ := ret[0].(nvml.ComputeMode)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetComputeMode indicates an expected call of GetComputeMode.
func (mr *MockGPUDeviceMockRecorder) GetComputeMode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComputeMode", reflect.TypeOf((*MockGPUDevice)(nil).GetComputeMode))
}

// GetComputeRunningProcesses mocks base method.
func (m *MockGPUDevice) GetComputeRunningProcesses() ([]nvml.ProcessInfo, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetComputeRunningProcesses")
	ret0, _ := ret[0].([]nvml.ProcessInfo)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetComputeRunningProcesses indicates an expected call of GetComputeRunningProcesses.
func (mr *MockGPUDeviceMockRecorder) GetComputeRunningProcesses() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComputeRunningProcesses", reflect.TypeOf((*MockGPUDevice)(nil).GetComputeRunningProcesses))
}

// GetConfComputeGpuAttestationReport mocks base method.
func (m *MockGPUDevice) GetConfComputeGpuAttestationReport() (nvml.ConfComputeGpuAttestationReport, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfComputeGpuAttestationReport")
	ret0, _ := ret[0].(nvml.ConfComputeGpuAttestationReport)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetConfComputeGpuAttestationReport indicates an expected call of GetConfComputeGpuAttestationReport.
func (mr *MockGPUDeviceMockRecorder) GetConfComputeGpuAttestationReport() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfComputeGpuAttestationReport", reflect.TypeOf((*MockGPUDevice)(nil).GetConfComputeGpuAttestationReport))
}

// GetConfComputeGpuCertificate mocks base method.
func (m *MockGPUDevice) GetConfComputeGpuCertificate() (nvml.ConfComputeGpuCertificate, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfComputeGpuCertificate")
	ret0, _ := ret[0].(nvml.ConfComputeGpuCertificate)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetConfComputeGpuCertificate indicates an expected call of GetConfComputeGpuCertificate.
func (mr *MockGPUDeviceMockRecorder) GetConfComputeGpuCertificate() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfComputeGpuCertificate", reflect.TypeOf((*MockGPUDevice)(nil).GetConfComputeGpuCertificate))
}

// GetConfComputeMemSizeInfo mocks base method.
func (m *MockGPUDevice) GetConfComputeMemSizeInfo() (nvml.ConfComputeMemSizeInfo, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfComputeMemSizeInfo")
	ret0, _ := ret[0].(nvml.ConfComputeMemSizeInfo)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetConfComputeMemSizeInfo indicates an expected call of GetConfComputeMemSizeInfo.
func (mr *MockGPUDeviceMockRecorder) GetConfComputeMemSizeInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfComputeMemSizeInfo", reflect.TypeOf((*MockGPUDevice)(nil).GetConfComputeMemSizeInfo))
}

// GetConfComputeProtectedMemoryUsage mocks base method.
func (m *MockGPUDevice) GetConfComputeProtectedMemoryUsage() (nvml.Memory, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfComputeProtectedMemoryUsage")
	ret0, _ := ret[0].(nvml.Memory)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetConfComputeProtectedMemoryUsage indicates an expected call of GetConfComputeProtectedMemoryUsage.
func (mr *MockGPUDeviceMockRecorder) GetConfComputeProtectedMemoryUsage() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfComputeProtectedMemoryUsage", reflect.TypeOf((*MockGPUDevice)(nil).GetConfComputeProtectedMemoryUsage))
}

// GetCpuAffinity mocks base method.
func (m *MockGPUDevice) GetCpuAffinity(arg0 int) ([]uint, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCpuAffinity", arg0)
	ret0, _ := ret[0].([]uint)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetCpuAffinity indicates an expected call of GetCpuAffinity.
func (mr *MockGPUDeviceMockRecorder) GetCpuAffinity(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCpuAffinity", reflect.TypeOf((*MockGPUDevice)(nil).GetCpuAffinity), arg0)
}

// GetCpuAffinityWithinScope mocks base method.
func (m *MockGPUDevice) GetCpuAffinityWithinScope(arg0 int, arg1 nvml.AffinityScope) ([]uint, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCpuAffinityWithinScope", arg0, arg1)
	ret0, _ := ret[0].([]uint)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetCpuAffinityWithinScope indicates an expected call of GetCpuAffinityWithinScope.
func (mr *MockGPUDeviceMockRecorder) GetCpuAffinityWithinScope(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCpuAffinityWithinScope", reflect.TypeOf((*MockGPUDevice)(nil).GetCpuAffinityWithinScope), arg0, arg1)
}

// GetCreatableVgpus mocks base method.
func (m *MockGPUDevice) GetCreatableVgpus() ([]nvml.VgpuTypeId, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCreatableVgpus")
	ret0, _ := ret[0].([]nvml.VgpuTypeId)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetCreatableVgpus indicates an expected call of GetCreatableVgpus.
func (mr *MockGPUDeviceMockRecorder) GetCreatableVgpus() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCreatableVgpus", reflect.TypeOf((*MockGPUDevice)(nil).GetCreatableVgpus))
}

// GetCudaComputeCapability mocks base method.
func (m *MockGPUDevice) GetCudaComputeCapability() (int, int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCudaComputeCapability")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetCudaComputeCapability indicates an expected call of GetCudaComputeCapability.
func (mr *MockGPUDeviceMockRecorder) GetCudaComputeCapability() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCudaComputeCapability", reflect.TypeOf((*MockGPUDevice)(nil).GetCudaComputeCapability))
}

// GetCurrPcieLinkGeneration mocks base method.
func (m *MockGPUDevice) GetCurrPcieLinkGeneration() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrPcieLinkGeneration")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetCurrPcieLinkGeneration indicates an expected call of GetCurrPcieLinkGeneration.
func (mr *MockGPUDeviceMockRecorder) GetCurrPcieLinkGeneration() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrPcieLinkGeneration", reflect.TypeOf((*MockGPUDevice)(nil).GetCurrPcieLinkGeneration))
}

// GetCurrPcieLinkWidth mocks base method.
func (m *MockGPUDevice) GetCurrPcieLinkWidth() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrPcieLinkWidth")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetCurrPcieLinkWidth indicates an expected call of GetCurrPcieLinkWidth.
func (mr *MockGPUDeviceMockRecorder) GetCurrPcieLinkWidth() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrPcieLinkWidth", reflect.TypeOf((*MockGPUDevice)(nil).GetCurrPcieLinkWidth))
}

// GetCurrentClocksEventReasons mocks base method.
func (m *MockGPUDevice) GetCurrentClocksEventReasons() (uint64, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentClocksEventReasons")
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetCurrentClocksEventReasons indicates an expected call of GetCurrentClocksEventReasons.
func (mr *MockGPUDeviceMockRecorder) GetCurrentClocksEventReasons() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentClocksEventReasons", reflect.TypeOf((*MockGPUDevice)(nil).GetCurrentClocksEventReasons))
}

// GetCurrentClocksThrottleReasons mocks base method.
func (m *MockGPUDevice) GetCurrentClocksThrottleReasons() (uint64, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentClocksThrottleReasons")
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetCurrentClocksThrottleReasons indicates an expected call of GetCurrentClocksThrottleReasons.
func (mr *MockGPUDeviceMockRecorder) GetCurrentClocksThrottleReasons() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentClocksThrottleReasons", reflect.TypeOf((*MockGPUDevice)(nil).GetCurrentClocksThrottleReasons))
}

// GetDecoderUtilization mocks base method.
func (m *MockGPUDevice) GetDecoderUtilization() (uint32, uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDecoderUtilization")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(uint32)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetDecoderUtilization indicates an expected call of GetDecoderUtilization.
func (mr *MockGPUDeviceMockRecorder) GetDecoderUtilization() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDecoderUtilization", reflect.TypeOf((*MockGPUDevice)(nil).GetDecoderUtilization))
}

// GetDefaultApplicationsClock mocks base method.
func (m *MockGPUDevice) GetDefaultApplicationsClock(arg0 nvml.ClockType) (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultApplicationsClock", arg0)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetDefaultApplicationsClock indicates an expected call of GetDefaultApplicationsClock.
func (mr *MockGPUDeviceMockRecorder) GetDefaultApplicationsClock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultApplicationsClock", reflect.TypeOf((*MockGPUDevice)(nil).GetDefaultApplicationsClock), arg0)
}

// GetDefaultEccMode mocks base method.
func (m *MockGPUDevice) GetDefaultEccMode() (nvml.EnableState, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultEccMode")
	ret0, _ := ret[0].(nvml.EnableState)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetDefaultEccMode indicates an expected call of GetDefaultEccMode.
func (mr *MockGPUDeviceMockRecorder) GetDefaultEccMode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultEccMode", reflect.TypeOf((*MockGPUDevice)(nil).GetDefaultEccMode))
}

// GetDetailedEccErrors mocks base method.
func (m *MockGPUDevice) GetDetailedEccErrors(arg0 nvml.MemoryErrorType, arg1 nvml.EccCounterType) (nvml.EccErrorCounts, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDetailedEccErrors", arg0, arg1)
	ret0, _ := ret[0].(nvml.EccErrorCounts)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetDetailedEccErrors indicates an expected call of GetDetailedEccErrors.
func (mr *MockGPUDeviceMockRecorder) GetDetailedEccErrors(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDetailedEccErrors", reflect.TypeOf((*MockGPUDevice)(nil).GetDetailedEccErrors), arg0, arg1)
}

// GetDeviceHandleFromMigDeviceHandle mocks base method.
func (m *MockGPUDevice) GetDeviceHandleFromMigDeviceHandle() (nvml.Device, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeviceHandleFromMigDeviceHandle")
	ret0, _ := ret[0].(nvml.Device)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetDeviceHandleFromMigDeviceHandle indicates an expected call of GetDeviceHandleFromMigDeviceHandle.
func (mr *MockGPUDeviceMockRecorder) GetDeviceHandleFromMigDeviceHandle() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeviceHandleFromMigDeviceHandle", reflect.TypeOf((*MockGPUDevice)(nil).GetDeviceHandleFromMigDeviceHandle))
}

// GetDisplayActive mocks base method.
func (m *MockGPUDevice) GetDisplayActive() (nvml.EnableState, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDisplayActive")
	ret0, _ := ret[0].(nvml.EnableState)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetDisplayActive indicates an expected call of GetDisplayActive.
func (mr *MockGPUDeviceMockRecorder) GetDisplayActive() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDisplayActive", reflect.TypeOf((*MockGPUDevice)(nil).GetDisplayActive))
}

// GetDisplayMode mocks base method.
func (m *MockGPUDevice) GetDisplayMode() (nvml.EnableState, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDisplayMode")
	ret0, _ := ret[0].(nvml.EnableState)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetDisplayMode indicates an expected call of GetDisplayMode.
func (mr *MockGPUDeviceMockRecorder) GetDisplayMode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDisplayMode", reflect.TypeOf((*MockGPUDevice)(nil).GetDisplayMode))
}

// GetDriverModel mocks base method.
func (m *MockGPUDevice) GetDriverModel() (nvml.DriverModel, nvml.DriverModel, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDriverModel")
	ret0, _ := ret[0].(nvml.DriverModel)
	ret1, _ := ret[1].(nvml.DriverModel)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetDriverModel indicates an expected call of GetDriverModel.
func (mr *MockGPUDeviceMockRecorder) GetDriverModel() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDriverModel", reflect.TypeOf((*MockGPUDevice)(nil).GetDriverModel))
}

// GetDynamicPstatesInfo mocks base method.
func (m *MockGPUDevice) GetDynamicPstatesInfo() (nvml.GpuDynamicPstatesInfo, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDynamicPstatesInfo")
	ret0, _ := ret[0].(nvml.GpuDynamicPstatesInfo)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetDynamicPstatesInfo indicates an expected call of GetDynamicPstatesInfo.
func (mr *MockGPUDeviceMockRecorder) GetDynamicPstatesInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDynamicPstatesInfo", reflect.TypeOf((*MockGPUDevice)(nil).GetDynamicPstatesInfo))
}

// GetEccMode mocks base method.
func (m *MockGPUDevice) GetEccMode() (nvml.EnableState, nvml.EnableState, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEccMode")
	ret0, _ := ret[0].(nvml.EnableState)
	ret1, _ := ret[1].(nvml.EnableState)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetEccMode indicates an expected call of GetEccMode.
func (mr *MockGPUDeviceMockRecorder) GetEccMode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEccMode", reflect.TypeOf((*MockGPUDevice)(nil).GetEccMode))
}

// GetEncoderCapacity mocks base method.
func (m *MockGPUDevice) GetEncoderCapacity(arg0 nvml.EncoderType) (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEncoderCapacity", arg0)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetEncoderCapacity indicates an expected call of GetEncoderCapacity.
func (mr *MockGPUDeviceMockRecorder) GetEncoderCapacity(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEncoderCapacity", reflect.TypeOf((*MockGPUDevice)(nil).GetEncoderCapacity), arg0)
}

// GetEncoderSessions mocks base method.
func (m *MockGPUDevice) GetEncoderSessions() ([]nvml.EncoderSessionInfo, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEncoderSessions")
	ret0, _ := ret[0].([]nvml.EncoderSessionInfo)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetEncoderSessions indicates an expected call of GetEncoderSessions.
func (mr *MockGPUDeviceMockRecorder) GetEncoderSessions() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEncoderSessions", reflect.TypeOf((*MockGPUDevice)(nil).GetEncoderSessions))
}

// GetEncoderStats mocks base method.
func (m *MockGPUDevice) GetEncoderStats() (int, uint32, uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEncoderStats")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(uint32)
	ret2, _ := ret[2].(uint32)
	ret3, _ := ret[3].(nvml.Return)
	return ret0, ret1, ret2, ret3
}

// GetEncoderStats indicates an expected call of GetEncoderStats.
func (mr *MockGPUDeviceMockRecorder) GetEncoderStats() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEncoderStats", reflect.TypeOf((*MockGPUDevice)(nil).GetEncoderStats))
}

// GetEncoderUtilization mocks base method.
func (m *MockGPUDevice) GetEncoderUtilization() (uint32, uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEncoderUtilization")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(uint32)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetEncoderUtilization indicates an expected call of GetEncoderUtilization.
func (mr *MockGPUDeviceMockRecorder) GetEncoderUtilization() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEncoderUtilization", reflect.TypeOf((*MockGPUDevice)(nil).GetEncoderUtilization))
}

// GetEnforcedPowerLimit mocks base method.
func (m *MockGPUDevice) GetEnforcedPowerLimit() (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEnforcedPowerLimit")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetEnforcedPowerLimit indicates an expected call of GetEnforcedPowerLimit.
func (mr *MockGPUDeviceMockRecorder) GetEnforcedPowerLimit() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEnforcedPowerLimit", reflect.TypeOf((*MockGPUDevice)(nil).GetEnforcedPowerLimit))
}

// GetFBCSessions mocks base method.
func (m *MockGPUDevice) GetFBCSessions() ([]nvml.FBCSessionInfo, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFBCSessions")
	ret0, _ := ret[0].([]nvml.FBCSessionInfo)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetFBCSessions indicates an expected call of GetFBCSessions.
func (mr *MockGPUDeviceMockRecorder) GetFBCSessions() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFBCSessions", reflect.TypeOf((*MockGPUDevice)(nil).GetFBCSessions))
}

// GetFBCStats mocks base method.
func (m *MockGPUDevice) GetFBCStats() (nvml.FBCStats, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFBCStats")
	ret0, _ := ret[0].(nvml.FBCStats)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetFBCStats indicates an expected call of GetFBCStats.
func (mr *MockGPUDeviceMockRecorder) GetFBCStats() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFBCStats", reflect.TypeOf((*MockGPUDevice)(nil).GetFBCStats))
}

// GetFanControlPolicy_v2 mocks base method.
func (m *MockGPUDevice) GetFanControlPolicy_v2(arg0 int) (nvml.FanControlPolicy, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFanControlPolicy_v2", arg0)
	ret0, _ := ret[0].(nvml.FanControlPolicy)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetFanControlPolicy_v2 indicates an expected call of GetFanControlPolicy_v2.
func (mr *MockGPUDeviceMockRecorder) GetFanControlPolicy_v2(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFanControlPolicy_v2", reflect.TypeOf((*MockGPUDevice)(nil).GetFanControlPolicy_v2), arg0)
}

// GetFanSpeed mocks base method.
func (m *MockGPUDevice) GetFanSpeed() (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFanSpeed")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetFanSpeed indicates an expected call of GetFanSpeed.
func (mr *MockGPUDeviceMockRecorder) GetFanSpeed() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFanSpeed", reflect.TypeOf((*MockGPUDevice)(nil).GetFanSpeed))
}

// GetFanSpeed_v2 mocks base method.
func (m *MockGPUDevice) GetFanSpeed_v2(arg0 int) (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFanSpeed_v2", arg0)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetFanSpeed_v2 indicates an expected call of GetFanSpeed_v2.
func (mr *MockGPUDeviceMockRecorder) GetFanSpeed_v2(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFanSpeed_v2", reflect.TypeOf((*MockGPUDevice)(nil).GetFanSpeed_v2), arg0)
}

// GetFieldValues mocks base method.
func (m *MockGPUDevice) GetFieldValues(arg0 []nvml.FieldValue) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFieldValues", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// GetFieldValues indicates an expected call of GetFieldValues.
func (mr *MockGPUDeviceMockRecorder) GetFieldValues(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFieldValues", reflect.TypeOf((*MockGPUDevice)(nil).GetFieldValues), arg0)
}

// GetGpcClkMinMaxVfOffset mocks base method.
func (m *MockGPUDevice) GetGpcClkMinMaxVfOffset() (int, int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGpcClkMinMaxVfOffset")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetGpcClkMinMaxVfOffset indicates an expected call of GetGpcClkMinMaxVfOffset.
func (mr *MockGPUDeviceMockRecorder) GetGpcClkMinMaxVfOffset() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpcClkMinMaxVfOffset", reflect.TypeOf((*MockGPUDevice)(nil).GetGpcClkMinMaxVfOffset))
}

// GetGpcClkVfOffset mocks base method.
func (m *MockGPUDevice) GetGpcClkVfOffset() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGpcClkVfOffset")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetGpcClkVfOffset indicates an expected call of GetGpcClkVfOffset.
func (mr *MockGPUDeviceMockRecorder) GetGpcClkVfOffset() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpcClkVfOffset", reflect.TypeOf((*MockGPUDevice)(nil).GetGpcClkVfOffset))
}

// GetGpuFabricInfo mocks base method.
func (m *MockGPUDevice) GetGpuFabricInfo() (nvml.GpuFabricInfo, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGpuFabricInfo")
	ret0, _ := ret[0].(nvml.GpuFabricInfo)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetGpuFabricInfo indicates an expected call of GetGpuFabricInfo.
func (mr *MockGPUDeviceMockRecorder) GetGpuFabricInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuFabricInfo", reflect.TypeOf((*MockGPUDevice)(nil).GetGpuFabricInfo))
}

// GetGpuFabricInfoV mocks base method.
func (m *MockGPUDevice) GetGpuFabricInfoV() nvml.GpuFabricInfoHandler {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGpuFabricInfoV")
	ret0, _ := ret[0].(nvml.GpuFabricInfoHandler)
	return ret0
}

// GetGpuFabricInfoV indicates an expected call of GetGpuFabricInfoV.
func (mr *MockGPUDeviceMockRecorder) GetGpuFabricInfoV() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuFabricInfoV", reflect.TypeOf((*MockGPUDevice)(nil).GetGpuFabricInfoV))
}

// GetGpuInstanceById mocks base method.
func (m *MockGPUDevice) GetGpuInstanceById(arg0 int) (nvml.GpuInstance, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGpuInstanceById", arg0)
	ret0, _ := ret[0].(nvml.GpuInstance)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetGpuInstanceById indicates an expected call of GetGpuInstanceById.
func (mr *MockGPUDeviceMockRecorder) GetGpuInstanceById(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuInstanceById", reflect.TypeOf((*MockGPUDevice)(nil).GetGpuInstanceById), arg0)
}

// GetGpuInstanceId mocks base method.
func (m *MockGPUDevice) GetGpuInstanceId() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGpuInstanceId")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetGpuInstanceId indicates an expected call of GetGpuInstanceId.
func (mr *MockGPUDeviceMockRecorder) GetGpuInstanceId() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuInstanceId", reflect.TypeOf((*MockGPUDevice)(nil).GetGpuInstanceId))
}

// GetGpuInstancePossiblePlacements mocks base method.
func (m *MockGPUDevice) GetGpuInstancePossiblePlacements(arg0 *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstancePlacement, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGpuInstancePossiblePlacements", arg0)
	ret0, _ := ret[0].([]nvml.GpuInstancePlacement)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetGpuInstancePossiblePlacements indicates an expected call of GetGpuInstancePossiblePlacements.
func (mr *MockGPUDeviceMockRecorder) GetGpuInstancePossiblePlacements(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuInstancePossiblePlacements", reflect.TypeOf((*MockGPUDevice)(nil).GetGpuInstancePossiblePlacements), arg0)
}

// GetGpuInstanceProfileInfo mocks base method.
func (m *MockGPUDevice) GetGpuInstanceProfileInfo(arg0 int) (nvml.GpuInstanceProfileInfo, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGpuInstanceProfileInfo", arg0)
	ret0, _ := ret[0].(nvml.GpuInstanceProfileInfo)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetGpuInstanceProfileInfo indicates an expected call of GetGpuInstanceProfileInfo.
func (mr *MockGPUDeviceMockRecorder) GetGpuInstanceProfileInfo(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuInstanceProfileInfo", reflect.TypeOf((*MockGPUDevice)(nil).GetGpuInstanceProfileInfo), arg0)
}

// GetGpuInstanceProfileInfoV mocks base method.
func (m *MockGPUDevice) GetGpuInstanceProfileInfoV(arg0 int) nvml.GpuInstanceProfileInfoHandler {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGpuInstanceProfileInfoV", arg0)
	ret0, _ := ret[0].(nvml.GpuInstanceProfileInfoHandler)
	return ret0
}

// GetGpuInstanceProfileInfoV indicates an expected call of GetGpuInstanceProfileInfoV.
func (mr *MockGPUDeviceMockRecorder) GetGpuInstanceProfileInfoV(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuInstanceProfileInfoV", reflect.TypeOf((*MockGPUDevice)(nil).GetGpuInstanceProfileInfoV), arg0)
}

// GetGpuInstanceRemainingCapacity mocks base method.
func (m *MockGPUDevice) GetGpuInstanceRemainingCapacity(arg0 *nvml.GpuInstanceProfileInfo) (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGpuInstanceRemainingCapacity", arg0)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetGpuInstanceRemainingCapacity indicates an expected call of GetGpuInstanceRemainingCapacity.
func (mr *MockGPUDeviceMockRecorder) GetGpuInstanceRemainingCapacity(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuInstanceRemainingCapacity", reflect.TypeOf((*MockGPUDevice)(nil).GetGpuInstanceRemainingCapacity), arg0)
}

// GetGpuInstances mocks base method.
func (m *MockGPUDevice) GetGpuInstances(arg0 *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstance, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGpuInstances", arg0)
	ret0, _ := ret[0].([]nvml.GpuInstance)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetGpuInstances indicates an expected call of GetGpuInstances.
func (mr *MockGPUDeviceMockRecorder) GetGpuInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuInstances", reflect.TypeOf((*MockGPUDevice)(nil).GetGpuInstances), arg0)
}

// GetGpuMaxPcieLinkGeneration mocks base method.
func (m *MockGPUDevice) GetGpuMaxPcieLinkGeneration() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGpuMaxPcieLinkGeneration")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetGpuMaxPcieLinkGeneration indicates an expected call of GetGpuMaxPcieLinkGeneration.
func (mr *MockGPUDeviceMockRecorder) GetGpuMaxPcieLinkGeneration() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuMaxPcieLinkGeneration", reflect.TypeOf((*MockGPUDevice)(nil).GetGpuMaxPcieLinkGeneration))
}

// GetGpuOperationMode mocks base method.
func (m *MockGPUDevice) GetGpuOperationMode() (nvml.GpuOperationMode, nvml.GpuOperationMode, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGpuOperationMode")
	ret0, _ := ret[0].(nvml.GpuOperationMode)
	ret1, _ := ret[1].(nvml.GpuOperationMode)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetGpuOperationMode indicates an expected call of GetGpuOperationMode.
func (mr *MockGPUDeviceMockRecorder) GetGpuOperationMode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuOperationMode", reflect.TypeOf((*MockGPUDevice)(nil).GetGpuOperationMode))
}

// GetGraphicsRunningProcesses mocks base method.
func (m *MockGPUDevice) GetGraphicsRunningProcesses() ([]nvml.ProcessInfo, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGraphicsRunningProcesses")
	ret0, _ := ret[0].([]nvml.ProcessInfo)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetGraphicsRunningProcesses indicates an expected call of GetGraphicsRunningProcesses.
func (mr *MockGPUDeviceMockRecorder) GetGraphicsRunningProcesses() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGraphicsRunningProcesses", reflect.TypeOf((*MockGPUDevice)(nil).GetGraphicsRunningProcesses))
}

// GetGridLicensableFeatures mocks base method.
func (m *MockGPUDevice) GetGridLicensableFeatures() (nvml.GridLicensableFeatures, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGridLicensableFeatures")
	ret0, _ := ret[0].(nvml.GridLicensableFeatures)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetGridLicensableFeatures indicates an expected call of GetGridLicensableFeatures.
func (mr *MockGPUDeviceMockRecorder) GetGridLicensableFeatures() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGridLicensableFeatures", reflect.TypeOf((*MockGPUDevice)(nil).GetGridLicensableFeatures))
}

// GetGspFirmwareMode mocks base method.
func (m *MockGPUDevice) GetGspFirmwareMode() (bool, bool, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGspFirmwareMode")
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetGspFirmwareMode indicates an expected call of GetGspFirmwareMode.
func (mr *MockGPUDeviceMockRecorder) GetGspFirmwareMode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGspFirmwareMode", reflect.TypeOf((*MockGPUDevice)(nil).GetGspFirmwareMode))
}

// GetGspFirmwareVersion mocks base method.
func (m *MockGPUDevice) GetGspFirmwareVersion() (string, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGspFirmwareVersion")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetGspFirmwareVersion indicates an expected call of GetGspFirmwareVersion.
func (mr *MockGPUDeviceMockRecorder) GetGspFirmwareVersion() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGspFirmwareVersion", reflect.TypeOf((*MockGPUDevice)(nil).GetGspFirmwareVersion))
}

// GetHostVgpuMode mocks base method.
func (m *MockGPUDevice) GetHostVgpuMode() (nvml.HostVgpuMode, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHostVgpuMode")
	ret0, _ := ret[0].(nvml.HostVgpuMode)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetHostVgpuMode indicates an expected call of GetHostVgpuMode.
func (mr *MockGPUDeviceMockRecorder) GetHostVgpuMode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostVgpuMode", reflect.TypeOf((*MockGPUDevice)(nil).GetHostVgpuMode))
}

// GetIndex mocks base method.
func (m *MockGPUDevice) GetIndex() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIndex")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetIndex indicates an expected call of GetIndex.
func (mr *MockGPUDeviceMockRecorder) GetIndex() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIndex", reflect.TypeOf((*MockGPUDevice)(nil).GetIndex))
}

// GetInforomConfigurationChecksum mocks base method.
func (m *MockGPUDevice) GetInforomConfigurationChecksum() (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInforomConfigurationChecksum")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetInforomConfigurationChecksum indicates an expected call of GetInforomConfigurationChecksum.
func (mr *MockGPUDeviceMockRecorder) GetInforomConfigurationChecksum() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInforomConfigurationChecksum", reflect.TypeOf((*MockGPUDevice)(nil).GetInforomConfigurationChecksum))
}

// GetInforomImageVersion mocks base method.
func (m *MockGPUDevice) GetInforomImageVersion() (string, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInforomImageVersion")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetInforomImageVersion indicates an expected call of GetInforomImageVersion.
func (mr *MockGPUDeviceMockRecorder) GetInforomImageVersion() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInforomImageVersion", reflect.TypeOf((*MockGPUDevice)(nil).GetInforomImageVersion))
}

// GetInforomVersion mocks base method.
func (m *MockGPUDevice) GetInforomVersion(arg0 nvml.InforomObject) (string, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInforomVersion", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetInforomVersion indicates an expected call of GetInforomVersion.
func (mr *MockGPUDeviceMockRecorder) GetInforomVersion(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInforomVersion", reflect.TypeOf((*MockGPUDevice)(nil).GetInforomVersion), arg0)
}

// GetIrqNum mocks base method.
func (m *MockGPUDevice) GetIrqNum() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIrqNum")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetIrqNum indicates an expected call of GetIrqNum.
func (mr *MockGPUDeviceMockRecorder) GetIrqNum() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIrqNum", reflect.TypeOf((*MockGPUDevice)(nil).GetIrqNum))
}

// GetJpgUtilization mocks base method.
func (m *MockGPUDevice) GetJpgUtilization() (uint32, uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetJpgUtilization")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(uint32)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetJpgUtilization indicates an expected call of GetJpgUtilization.
func (mr *MockGPUDeviceMockRecorder) GetJpgUtilization() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJpgUtilization", reflect.TypeOf((*MockGPUDevice)(nil).GetJpgUtilization))
}

// GetLastBBXFlushTime mocks base method.
func (m *MockGPUDevice) GetLastBBXFlushTime() (uint64, uint, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLastBBXFlushTime")
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(uint)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetLastBBXFlushTime indicates an expected call of GetLastBBXFlushTime.
func (mr *MockGPUDeviceMockRecorder) GetLastBBXFlushTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastBBXFlushTime", reflect.TypeOf((*MockGPUDevice)(nil).GetLastBBXFlushTime))
}

// GetMPSComputeRunningProcesses mocks base method.
func (m *MockGPUDevice) GetMPSComputeRunningProcesses() ([]nvml.ProcessInfo, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMPSComputeRunningProcesses")
	ret0, _ := ret[0].([]nvml.ProcessInfo)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMPSComputeRunningProcesses indicates an expected call of GetMPSComputeRunningProcesses.
func (mr *MockGPUDeviceMockRecorder) GetMPSComputeRunningProcesses() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMPSComputeRunningProcesses", reflect.TypeOf((*MockGPUDevice)(nil).GetMPSComputeRunningProcesses))
}

// GetMaxClockInfo mocks base method.
func (m *MockGPUDevice) GetMaxClockInfo(arg0 nvml.ClockType) (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMaxClockInfo", arg0)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMaxClockInfo indicates an expected call of GetMaxClockInfo.
func (mr *MockGPUDeviceMockRecorder) GetMaxClockInfo(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxClockInfo", reflect.TypeOf((*MockGPUDevice)(nil).GetMaxClockInfo), arg0)
}

// GetMaxCustomerBoostClock mocks base method.
func (m *MockGPUDevice) GetMaxCustomerBoostClock(arg0 nvml.ClockType) (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMaxCustomerBoostClock", arg0)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMaxCustomerBoostClock indicates an expected call of GetMaxCustomerBoostClock.
func (mr *MockGPUDeviceMockRecorder) GetMaxCustomerBoostClock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxCustomerBoostClock", reflect.TypeOf((*MockGPUDevice)(nil).GetMaxCustomerBoostClock), arg0)
}

// GetMaxMigDeviceCount mocks base method.
func (m *MockGPUDevice) GetMaxMigDeviceCount() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMaxMigDeviceCount")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMaxMigDeviceCount indicates an expected call of GetMaxMigDeviceCount.
func (mr *MockGPUDeviceMockRecorder) GetMaxMigDeviceCount() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxMigDeviceCount", reflect.TypeOf((*MockGPUDevice)(nil).GetMaxMigDeviceCount))
}

// GetMaxPcieLinkGeneration mocks base method.
func (m *MockGPUDevice) GetMaxPcieLinkGeneration() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMaxPcieLinkGeneration")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMaxPcieLinkGeneration indicates an expected call of GetMaxPcieLinkGeneration.
func (mr *MockGPUDeviceMockRecorder) GetMaxPcieLinkGeneration() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxPcieLinkGeneration", reflect.TypeOf((*MockGPUDevice)(nil).GetMaxPcieLinkGeneration))
}

// GetMaxPcieLinkWidth mocks base method.
func (m *MockGPUDevice) GetMaxPcieLinkWidth() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMaxPcieLinkWidth")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMaxPcieLinkWidth indicates an expected call of GetMaxPcieLinkWidth.
func (mr *MockGPUDeviceMockRecorder) GetMaxPcieLinkWidth() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxPcieLinkWidth", reflect.TypeOf((*MockGPUDevice)(nil).GetMaxPcieLinkWidth))
}

// GetMemClkMinMaxVfOffset mocks base method.
func (m *MockGPUDevice) GetMemClkMinMaxVfOffset() (int, int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMemClkMinMaxVfOffset")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetMemClkMinMaxVfOffset indicates an expected call of GetMemClkMinMaxVfOffset.
func (mr *MockGPUDeviceMockRecorder) GetMemClkMinMaxVfOffset() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMemClkMinMaxVfOffset", reflect.TypeOf((*MockGPUDevice)(nil).GetMemClkMinMaxVfOffset))
}

// GetMemClkVfOffset mocks base method.
func (m *MockGPUDevice) GetMemClkVfOffset() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMemClkVfOffset")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMemClkVfOffset indicates an expected call of GetMemClkVfOffset.
func (mr *MockGPUDeviceMockRecorder) GetMemClkVfOffset() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMemClkVfOffset", reflect.TypeOf((*MockGPUDevice)(nil).GetMemClkVfOffset))
}

// GetMemoryAffinity mocks base method.
func (m *MockGPUDevice) GetMemoryAffinity(arg0 int, arg1 nvml.AffinityScope) ([]uint, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMemoryAffinity", arg0, arg1)
	ret0, _ := ret[0].([]uint)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMemoryAffinity indicates an expected call of GetMemoryAffinity.
func (mr *MockGPUDeviceMockRecorder) GetMemoryAffinity(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMemoryAffinity", reflect.TypeOf((*MockGPUDevice)(nil).GetMemoryAffinity), arg0, arg1)
}

// GetMemoryBusWidth mocks base method.
func (m *MockGPUDevice) GetMemoryBusWidth() (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMemoryBusWidth")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMemoryBusWidth indicates an expected call of GetMemoryBusWidth.
func (mr *MockGPUDeviceMockRecorder) GetMemoryBusWidth() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMemoryBusWidth", reflect.TypeOf((*MockGPUDevice)(nil).GetMemoryBusWidth))
}

// GetMemoryErrorCounter mocks base method.
func (m *MockGPUDevice) GetMemoryErrorCounter(arg0 nvml.MemoryErrorType, arg1 nvml.EccCounterType, arg2 nvml.MemoryLocation) (uint64, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMemoryErrorCounter", arg0, arg1, arg2)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMemoryErrorCounter indicates an expected call of GetMemoryErrorCounter.
func (mr *MockGPUDeviceMockRecorder) GetMemoryErrorCounter(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMemoryErrorCounter", reflect.TypeOf((*MockGPUDevice)(nil).GetMemoryErrorCounter), arg0, arg1, arg2)
}

// GetMemoryInfo mocks base method.
func (m *MockGPUDevice) GetMemoryInfo() (nvml.Memory, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMemoryInfo")
	ret0, _ := ret[0].(nvml.Memory)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMemoryInfo indicates an expected call of GetMemoryInfo.
func (mr *MockGPUDeviceMockRecorder) GetMemoryInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMemoryInfo", reflect.TypeOf((*MockGPUDevice)(nil).GetMemoryInfo))
}

// GetMemoryInfo_v2 mocks base method.
func (m *MockGPUDevice) GetMemoryInfo_v2() (nvml.Memory_v2, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMemoryInfo_v2")
	ret0, _ := ret[0].(nvml.Memory_v2)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMemoryInfo_v2 indicates an expected call of GetMemoryInfo_v2.
func (mr *MockGPUDeviceMockRecorder) GetMemoryInfo_v2() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMemoryInfo_v2", reflect.TypeOf((*MockGPUDevice)(nil).GetMemoryInfo_v2))
}

// GetMigDeviceHandleByIndex mocks base method.
func (m *MockGPUDevice) GetMigDeviceHandleByIndex(arg0 int) (nvml.Device, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMigDeviceHandleByIndex", arg0)
	ret0, _ := ret[0].(nvml.Device)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMigDeviceHandleByIndex indicates an expected call of GetMigDeviceHandleByIndex.
func (mr *MockGPUDeviceMockRecorder) GetMigDeviceHandleByIndex(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMigDeviceHandleByIndex", reflect.TypeOf((*MockGPUDevice)(nil).GetMigDeviceHandleByIndex), arg0)
}

// GetMigMode mocks base method.
func (m *MockGPUDevice) GetMigMode() (int, int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMigMode")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetMigMode indicates an expected call of GetMigMode.
func (mr *MockGPUDeviceMockRecorder) GetMigMode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMigMode", reflect.TypeOf((*MockGPUDevice)(nil).GetMigMode))
}

// GetMinMaxClockOfPState mocks base method.
func (m *MockGPUDevice) GetMinMaxClockOfPState(arg0 nvml.ClockType, arg1 nvml.Pstates) (uint32, uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMinMaxClockOfPState", arg0, arg1)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(uint32)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetMinMaxClockOfPState indicates an expected call of GetMinMaxClockOfPState.
func (mr *MockGPUDeviceMockRecorder) GetMinMaxClockOfPState(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMinMaxClockOfPState", reflect.TypeOf((*MockGPUDevice)(nil).GetMinMaxClockOfPState), arg0, arg1)
}

// GetMinMaxFanSpeed mocks base method.
func (m *MockGPUDevice) GetMinMaxFanSpeed() (int, int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMinMaxFanSpeed")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetMinMaxFanSpeed indicates an expected call of GetMinMaxFanSpeed.
func (mr *MockGPUDeviceMockRecorder) GetMinMaxFanSpeed() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMinMaxFanSpeed", reflect.TypeOf((*MockGPUDevice)(nil).GetMinMaxFanSpeed))
}

// GetMinorNumber mocks base method.
func (m *MockGPUDevice) GetMinorNumber() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMinorNumber")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMinorNumber indicates an expected call of GetMinorNumber.
func (mr *MockGPUDeviceMockRecorder) GetMinorNumber() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMinorNumber", reflect.TypeOf((*MockGPUDevice)(nil).GetMinorNumber))
}

// GetModuleId mocks base method.
func (m *MockGPUDevice) GetModuleId() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetModuleId")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetModuleId indicates an expected call of GetModuleId.
func (mr *MockGPUDeviceMockRecorder) GetModuleId() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModuleId", reflect.TypeOf((*MockGPUDevice)(nil).GetModuleId))
}

// GetMultiGpuBoard mocks base method.
func (m *MockGPUDevice) GetMultiGpuBoard() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMultiGpuBoard")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetMultiGpuBoard indicates an expected call of GetMultiGpuBoard.
func (mr *MockGPUDeviceMockRecorder) GetMultiGpuBoard() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMultiGpuBoard", reflect.TypeOf((*MockGPUDevice)(nil).GetMultiGpuBoard))
}

// GetName mocks base method.
func (m *MockGPUDevice) GetName() (string, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetName")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetName indicates an expected call of GetName.
func (mr *MockGPUDeviceMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockGPUDevice)(nil).GetName))
}

// GetNumFans mocks base method.
func (m *MockGPUDevice) GetNumFans() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNumFans")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetNumFans indicates an expected call of GetNumFans.
func (mr *MockGPUDeviceMockRecorder) GetNumFans() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNumFans", reflect.TypeOf((*MockGPUDevice)(nil).GetNumFans))
}

// GetNumGpuCores mocks base method.
func (m *MockGPUDevice) GetNumGpuCores() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNumGpuCores")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetNumGpuCores indicates an expected call of GetNumGpuCores.
func (mr *MockGPUDeviceMockRecorder) GetNumGpuCores() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNumGpuCores", reflect.TypeOf((*MockGPUDevice)(nil).GetNumGpuCores))
}

// GetNumaNodeId mocks base method.
func (m *MockGPUDevice) GetNumaNodeId() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNumaNodeId")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetNumaNodeId indicates an expected call of GetNumaNodeId.
func (mr *MockGPUDeviceMockRecorder) GetNumaNodeId() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNumaNodeId", reflect.TypeOf((*MockGPUDevice)(nil).GetNumaNodeId))
}

// GetNvLinkCapability mocks base method.
func (m *MockGPUDevice) GetNvLinkCapability(arg0 int, arg1 nvml.NvLinkCapability) (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNvLinkCapability", arg0, arg1)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetNvLinkCapability indicates an expected call of GetNvLinkCapability.
func (mr *MockGPUDeviceMockRecorder) GetNvLinkCapability(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNvLinkCapability", reflect.TypeOf((*MockGPUDevice)(nil).GetNvLinkCapability), arg0, arg1)
}

// GetNvLinkErrorCounter mocks base method.
func (m *MockGPUDevice) GetNvLinkErrorCounter(arg0 int, arg1 nvml.NvLinkErrorCounter) (uint64, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNvLinkErrorCounter", arg0, arg1)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetNvLinkErrorCounter indicates an expected call of GetNvLinkErrorCounter.
func (mr *MockGPUDeviceMockRecorder) GetNvLinkErrorCounter(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNvLinkErrorCounter", reflect.TypeOf((*MockGPUDevice)(nil).GetNvLinkErrorCounter), arg0, arg1)
}

// GetNvLinkRemoteDeviceType mocks base method.
func (m *MockGPUDevice) GetNvLinkRemoteDeviceType(arg0 int) (nvml.IntNvLinkDeviceType, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNvLinkRemoteDeviceType", arg0)
	ret0, _ := ret[0].(nvml.IntNvLinkDeviceType)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetNvLinkRemoteDeviceType indicates an expected call of GetNvLinkRemoteDeviceType.
func (mr *MockGPUDeviceMockRecorder) GetNvLinkRemoteDeviceType(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNvLinkRemoteDeviceType", reflect.TypeOf((*MockGPUDevice)(nil).GetNvLinkRemoteDeviceType), arg0)
}

// GetNvLinkRemotePciInfo mocks base method.
func (m *MockGPUDevice) GetNvLinkRemotePciInfo(arg0 int) (nvml.PciInfo, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNvLinkRemotePciInfo", arg0)
	ret0, _ := ret[0].(nvml.PciInfo)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetNvLinkRemotePciInfo indicates an expected call of GetNvLinkRemotePciInfo.
func (mr *MockGPUDeviceMockRecorder) GetNvLinkRemotePciInfo(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNvLinkRemotePciInfo", reflect.TypeOf((*MockGPUDevice)(nil).GetNvLinkRemotePciInfo), arg0)
}

// GetNvLinkState mocks base method.
func (m *MockGPUDevice) GetNvLinkState(arg0 int) (nvml.EnableState, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNvLinkState", arg0)
	ret0, _ := ret[0].(nvml.EnableState)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetNvLinkState indicates an expected call of GetNvLinkState.
func (mr *MockGPUDeviceMockRecorder) GetNvLinkState(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNvLinkState", reflect.TypeOf((*MockGPUDevice)(nil).GetNvLinkState), arg0)
}

// GetNvLinkUtilizationControl mocks base method.
func (m *MockGPUDevice) GetNvLinkUtilizationControl(arg0, arg1 int) (nvml.NvLinkUtilizationControl, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNvLinkUtilizationControl", arg0, arg1)
	ret0, _ := ret[0].(nvml.NvLinkUtilizationControl)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetNvLinkUtilizationControl indicates an expected call of GetNvLinkUtilizationControl.
func (mr *MockGPUDeviceMockRecorder) GetNvLinkUtilizationControl(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNvLinkUtilizationControl", reflect.TypeOf((*MockGPUDevice)(nil).GetNvLinkUtilizationControl), arg0, arg1)
}

// GetNvLinkUtilizationCounter mocks base method.
func (m *MockGPUDevice) GetNvLinkUtilizationCounter(arg0, arg1 int) (uint64, uint64, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNvLinkUtilizationCounter", arg0, arg1)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetNvLinkUtilizationCounter indicates an expected call of GetNvLinkUtilizationCounter.
func (mr *MockGPUDeviceMockRecorder) GetNvLinkUtilizationCounter(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNvLinkUtilizationCounter", reflect.TypeOf((*MockGPUDevice)(nil).GetNvLinkUtilizationCounter), arg0, arg1)
}

// GetNvLinkVersion mocks base method.
func (m *MockGPUDevice) GetNvLinkVersion(arg0 int) (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNvLinkVersion", arg0)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetNvLinkVersion indicates an expected call of GetNvLinkVersion.
func (mr *MockGPUDeviceMockRecorder) GetNvLinkVersion(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNvLinkVersion", reflect.TypeOf((*MockGPUDevice)(nil).GetNvLinkVersion), arg0)
}

// GetOfaUtilization mocks base method.
func (m *MockGPUDevice) GetOfaUtilization() (uint32, uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOfaUtilization")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(uint32)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetOfaUtilization indicates an expected call of GetOfaUtilization.
func (mr *MockGPUDeviceMockRecorder) GetOfaUtilization() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOfaUtilization", reflect.TypeOf((*MockGPUDevice)(nil).GetOfaUtilization))
}

// GetP2PStatus mocks base method.
func (m *MockGPUDevice) GetP2PStatus(arg0 nvml.Device, arg1 nvml.GpuP2PCapsIndex) (nvml.GpuP2PStatus, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetP2PStatus", arg0, arg1)
	ret0, _ := ret[0].(nvml.GpuP2PStatus)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetP2PStatus indicates an expected call of GetP2PStatus.
func (mr *MockGPUDeviceMockRecorder) GetP2PStatus(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetP2PStatus", reflect.TypeOf((*MockGPUDevice)(nil).GetP2PStatus), arg0, arg1)
}

// GetPciInfo mocks base method.
func (m *MockGPUDevice) GetPciInfo() (nvml.PciInfo, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPciInfo")
	ret0, _ := ret[0].(nvml.PciInfo)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPciInfo indicates an expected call of GetPciInfo.
func (mr *MockGPUDeviceMockRecorder) GetPciInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPciInfo", reflect.TypeOf((*MockGPUDevice)(nil).GetPciInfo))
}

// GetPciInfoExt mocks base method.
func (m *MockGPUDevice) GetPciInfoExt() (nvml.PciInfoExt, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPciInfoExt")
	ret0, _ := ret[0].(nvml.PciInfoExt)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPciInfoExt indicates an expected call of GetPciInfoExt.
func (mr *MockGPUDeviceMockRecorder) GetPciInfoExt() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPciInfoExt", reflect.TypeOf((*MockGPUDevice)(nil).GetPciInfoExt))
}

// GetPcieLinkMaxSpeed mocks base method.
func (m *MockGPUDevice) GetPcieLinkMaxSpeed() (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPcieLinkMaxSpeed")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPcieLinkMaxSpeed indicates an expected call of GetPcieLinkMaxSpeed.
func (mr *MockGPUDeviceMockRecorder) GetPcieLinkMaxSpeed() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPcieLinkMaxSpeed", reflect.TypeOf((*MockGPUDevice)(nil).GetPcieLinkMaxSpeed))
}

// GetPcieReplayCounter mocks base method.
func (m *MockGPUDevice) GetPcieReplayCounter() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPcieReplayCounter")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPcieReplayCounter indicates an expected call of GetPcieReplayCounter.
func (mr *MockGPUDeviceMockRecorder) GetPcieReplayCounter() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPcieReplayCounter", reflect.TypeOf((*MockGPUDevice)(nil).GetPcieReplayCounter))
}

// GetPcieSpeed mocks base method.
func (m *MockGPUDevice) GetPcieSpeed() (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPcieSpeed")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPcieSpeed indicates an expected call of GetPcieSpeed.
func (mr *MockGPUDeviceMockRecorder) GetPcieSpeed() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPcieSpeed", reflect.TypeOf((*MockGPUDevice)(nil).GetPcieSpeed))
}

// GetPcieThroughput mocks base method.
func (m *MockGPUDevice) GetPcieThroughput(arg0 nvml.PcieUtilCounter) (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPcieThroughput", arg0)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPcieThroughput indicates an expected call of GetPcieThroughput.
func (mr *MockGPUDeviceMockRecorder) GetPcieThroughput(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPcieThroughput", reflect.TypeOf((*MockGPUDevice)(nil).GetPcieThroughput), arg0)
}

// GetPerformanceState mocks base method.
func (m *MockGPUDevice) GetPerformanceState() (nvml.Pstates, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPerformanceState")
	ret0, _ := ret[0].(nvml.Pstates)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPerformanceState indicates an expected call of GetPerformanceState.
func (mr *MockGPUDeviceMockRecorder) GetPerformanceState() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPerformanceState", reflect.TypeOf((*MockGPUDevice)(nil).GetPerformanceState))
}

// GetPersistenceMode mocks base method.
func (m *MockGPUDevice) GetPersistenceMode() (nvml.EnableState, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPersistenceMode")
	ret0, _ := ret[0].(nvml.EnableState)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPersistenceMode indicates an expected call of GetPersistenceMode.
func (mr *MockGPUDeviceMockRecorder) GetPersistenceMode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPersistenceMode", reflect.TypeOf((*MockGPUDevice)(nil).GetPersistenceMode))
}

// GetPgpuMetadataString mocks base method.
func (m *MockGPUDevice) GetPgpuMetadataString() (string, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPgpuMetadataString")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPgpuMetadataString indicates an expected call of GetPgpuMetadataString.
func (mr *MockGPUDeviceMockRecorder) GetPgpuMetadataString() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPgpuMetadataString", reflect.TypeOf((*MockGPUDevice)(nil).GetPgpuMetadataString))
}

// GetPowerManagementDefaultLimit mocks base method.
func (m *MockGPUDevice) GetPowerManagementDefaultLimit() (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPowerManagementDefaultLimit")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPowerManagementDefaultLimit indicates an expected call of GetPowerManagementDefaultLimit.
func (mr *MockGPUDeviceMockRecorder) GetPowerManagementDefaultLimit() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPowerManagementDefaultLimit", reflect.TypeOf((*MockGPUDevice)(nil).GetPowerManagementDefaultLimit))
}

// GetPowerManagementLimit mocks base method.
func (m *MockGPUDevice) GetPowerManagementLimit() (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPowerManagementLimit")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPowerManagementLimit indicates an expected call of GetPowerManagementLimit.
func (mr *MockGPUDeviceMockRecorder) GetPowerManagementLimit() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPowerManagementLimit", reflect.TypeOf((*MockGPUDevice)(nil).GetPowerManagementLimit))
}

// GetPowerManagementLimitConstraints mocks base method.
func (m *MockGPUDevice) GetPowerManagementLimitConstraints() (uint32, uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPowerManagementLimitConstraints")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(uint32)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetPowerManagementLimitConstraints indicates an expected call of GetPowerManagementLimitConstraints.
func (mr *MockGPUDeviceMockRecorder) GetPowerManagementLimitConstraints() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPowerManagementLimitConstraints", reflect.TypeOf((*MockGPUDevice)(nil).GetPowerManagementLimitConstraints))
}

// GetPowerManagementMode mocks base method.
func (m *MockGPUDevice) GetPowerManagementMode() (nvml.EnableState, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPowerManagementMode")
	ret0, _ := ret[0].(nvml.EnableState)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPowerManagementMode indicates an expected call of GetPowerManagementMode.
func (mr *MockGPUDeviceMockRecorder) GetPowerManagementMode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPowerManagementMode", reflect.TypeOf((*MockGPUDevice)(nil).GetPowerManagementMode))
}

// GetPowerSource mocks base method.
func (m *MockGPUDevice) GetPowerSource() (nvml.PowerSource, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPowerSource")
	ret0, _ := ret[0].(nvml.PowerSource)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPowerSource indicates an expected call of GetPowerSource.
func (mr *MockGPUDeviceMockRecorder) GetPowerSource() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPowerSource", reflect.TypeOf((*MockGPUDevice)(nil).GetPowerSource))
}

// GetPowerState mocks base method.
func (m *MockGPUDevice) GetPowerState() (nvml.Pstates, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPowerState")
	ret0, _ := ret[0].(nvml.Pstates)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPowerState indicates an expected call of GetPowerState.
func (mr *MockGPUDeviceMockRecorder) GetPowerState() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPowerState", reflect.TypeOf((*MockGPUDevice)(nil).GetPowerState))
}

// GetPowerUsage mocks base method.
func (m *MockGPUDevice) GetPowerUsage() (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPowerUsage")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetPowerUsage indicates an expected call of GetPowerUsage.
func (mr *MockGPUDeviceMockRecorder) GetPowerUsage() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPowerUsage", reflect.TypeOf((*MockGPUDevice)(nil).GetPowerUsage))
}

// GetProcessUtilization mocks base method.
func (m *MockGPUDevice) GetProcessUtilization(arg0 uint64) ([]nvml.ProcessUtilizationSample, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProcessUtilization", arg0)
	ret0, _ := ret[0].([]nvml.ProcessUtilizationSample)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetProcessUtilization indicates an expected call of GetProcessUtilization.
func (mr *MockGPUDeviceMockRecorder) GetProcessUtilization(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProcessUtilization", reflect.TypeOf((*MockGPUDevice)(nil).GetProcessUtilization), arg0)
}

// GetProcessesUtilizationInfo mocks base method.
func (m *MockGPUDevice) GetProcessesUtilizationInfo() (nvml.ProcessesUtilizationInfo, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProcessesUtilizationInfo")
	ret0, _ := ret[0].(nvml.ProcessesUtilizationInfo)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetProcessesUtilizationInfo indicates an expected call of GetProcessesUtilizationInfo.
func (mr *MockGPUDeviceMockRecorder) GetProcessesUtilizationInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProcessesUtilizationInfo", reflect.TypeOf((*MockGPUDevice)(nil).GetProcessesUtilizationInfo))
}

// GetRemappedRows mocks base method.
func (m *MockGPUDevice) GetRemappedRows() (int, int, bool, bool, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRemappedRows")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(bool)
	ret3, _ := ret[3].(bool)
	ret4, _ := ret[4].(nvml.Return)
	return ret0, ret1, ret2, ret3, ret4
}

// GetRemappedRows indicates an expected call of GetRemappedRows.
func (mr *MockGPUDeviceMockRecorder) GetRemappedRows() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemappedRows", reflect.TypeOf((*MockGPUDevice)(nil).GetRemappedRows))
}

// GetRetiredPages mocks base method.
func (m *MockGPUDevice) GetRetiredPages(arg0 nvml.PageRetirementCause) ([]uint64, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRetiredPages", arg0)
	ret0, _ := ret[0].([]uint64)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetRetiredPages indicates an expected call of GetRetiredPages.
func (mr *MockGPUDeviceMockRecorder) GetRetiredPages(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetiredPages", reflect.TypeOf((*MockGPUDevice)(nil).GetRetiredPages), arg0)
}

// GetRetiredPagesPendingStatus mocks base method.
func (m *MockGPUDevice) GetRetiredPagesPendingStatus() (nvml.EnableState, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRetiredPagesPendingStatus")
	ret0, _ := ret[0].(nvml.EnableState)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetRetiredPagesPendingStatus indicates an expected call of GetRetiredPagesPendingStatus.
func (mr *MockGPUDeviceMockRecorder) GetRetiredPagesPendingStatus() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetiredPagesPendingStatus", reflect.TypeOf((*MockGPUDevice)(nil).GetRetiredPagesPendingStatus))
}

// GetRetiredPages_v2 mocks base method.
func (m *MockGPUDevice) GetRetiredPages_v2(arg0 nvml.PageRetirementCause) ([]uint64, []uint64, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRetiredPages_v2", arg0)
	ret0, _ := ret[0].([]uint64)
	ret1, _ := ret[1].([]uint64)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetRetiredPages_v2 indicates an expected call of GetRetiredPages_v2.
func (mr *MockGPUDeviceMockRecorder) GetRetiredPages_v2(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetiredPages_v2", reflect.TypeOf((*MockGPUDevice)(nil).GetRetiredPages_v2), arg0)
}

// GetRowRemapperHistogram mocks base method.
func (m *MockGPUDevice) GetRowRemapperHistogram() (nvml.RowRemapperHistogramValues, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRowRemapperHistogram")
	ret0, _ := ret[0].(nvml.RowRemapperHistogramValues)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetRowRemapperHistogram indicates an expected call of GetRowRemapperHistogram.
func (mr *MockGPUDeviceMockRecorder) GetRowRemapperHistogram() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRowRemapperHistogram", reflect.TypeOf((*MockGPUDevice)(nil).GetRowRemapperHistogram))
}

// GetRunningProcessDetailList mocks base method.
func (m *MockGPUDevice) GetRunningProcessDetailList() (nvml.ProcessDetailList, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRunningProcessDetailList")
	ret0, _ := ret[0].(nvml.ProcessDetailList)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetRunningProcessDetailList indicates an expected call of GetRunningProcessDetailList.
func (mr *MockGPUDeviceMockRecorder) GetRunningProcessDetailList() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRunningProcessDetailList", reflect.TypeOf((*MockGPUDevice)(nil).GetRunningProcessDetailList))
}

// GetSamples mocks base method.
func (m *MockGPUDevice) GetSamples(arg0 nvml.SamplingType, arg1 uint64) (nvml.ValueType, []nvml.Sample, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSamples", arg0, arg1)
	ret0, _ := ret[0].(nvml.ValueType)
	ret1, _ := ret[1].([]nvml.Sample)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetSamples indicates an expected call of GetSamples.
func (mr *MockGPUDeviceMockRecorder) GetSamples(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSamples", reflect.TypeOf((*MockGPUDevice)(nil).GetSamples), arg0, arg1)
}

// GetSerial mocks base method.
func (m *MockGPUDevice) GetSerial() (string, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSerial")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetSerial indicates an expected call of GetSerial.
func (mr *MockGPUDeviceMockRecorder) GetSerial() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSerial", reflect.TypeOf((*MockGPUDevice)(nil).GetSerial))
}

// GetSramEccErrorStatus mocks base method.
func (m *MockGPUDevice) GetSramEccErrorStatus() (nvml.EccSramErrorStatus, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSramEccErrorStatus")
	ret0, _ := ret[0].(nvml.EccSramErrorStatus)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetSramEccErrorStatus indicates an expected call of GetSramEccErrorStatus.
func (mr *MockGPUDeviceMockRecorder) GetSramEccErrorStatus() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSramEccErrorStatus", reflect.TypeOf((*MockGPUDevice)(nil).GetSramEccErrorStatus))
}

// GetSupportedClocksEventReasons mocks base method.
func (m *MockGPUDevice) GetSupportedClocksEventReasons() (uint64, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSupportedClocksEventReasons")
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetSupportedClocksEventReasons indicates an expected call of GetSupportedClocksEventReasons.
func (mr *MockGPUDeviceMockRecorder) GetSupportedClocksEventReasons() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSupportedClocksEventReasons", reflect.TypeOf((*MockGPUDevice)(nil).GetSupportedClocksEventReasons))
}

// GetSupportedClocksThrottleReasons mocks base method.
func (m *MockGPUDevice) GetSupportedClocksThrottleReasons() (uint64, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSupportedClocksThrottleReasons")
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetSupportedClocksThrottleReasons indicates an expected call of GetSupportedClocksThrottleReasons.
func (mr *MockGPUDeviceMockRecorder) GetSupportedClocksThrottleReasons() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSupportedClocksThrottleReasons", reflect.TypeOf((*MockGPUDevice)(nil).GetSupportedClocksThrottleReasons))
}

// GetSupportedEventTypes mocks base method.
func (m *MockGPUDevice) GetSupportedEventTypes() (uint64, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSupportedEventTypes")
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetSupportedEventTypes indicates an expected call of GetSupportedEventTypes.
func (mr *MockGPUDeviceMockRecorder) GetSupportedEventTypes() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSupportedEventTypes", reflect.TypeOf((*MockGPUDevice)(nil).GetSupportedEventTypes))
}

// GetSupportedGraphicsClocks mocks base method.
func (m *MockGPUDevice) GetSupportedGraphicsClocks(arg0 int) (int, uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSupportedGraphicsClocks", arg0)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(uint32)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetSupportedGraphicsClocks indicates an expected call of GetSupportedGraphicsClocks.
func (mr *MockGPUDeviceMockRecorder) GetSupportedGraphicsClocks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSupportedGraphicsClocks", reflect.TypeOf((*MockGPUDevice)(nil).GetSupportedGraphicsClocks), arg0)
}

// GetSupportedMemoryClocks mocks base method.
func (m *MockGPUDevice) GetSupportedMemoryClocks() (int, uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSupportedMemoryClocks")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(uint32)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetSupportedMemoryClocks indicates an expected call of GetSupportedMemoryClocks.
func (mr *MockGPUDeviceMockRecorder) GetSupportedMemoryClocks() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSupportedMemoryClocks", reflect.TypeOf((*MockGPUDevice)(nil).GetSupportedMemoryClocks))
}

// GetSupportedPerformanceStates mocks base method.
func (m *MockGPUDevice) GetSupportedPerformanceStates() ([]nvml.Pstates, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSupportedPerformanceStates")
	ret0, _ := ret[0].([]nvml.Pstates)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetSupportedPerformanceStates indicates an expected call of GetSupportedPerformanceStates.
func (mr *MockGPUDeviceMockRecorder) GetSupportedPerformanceStates() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSupportedPerformanceStates", reflect.TypeOf((*MockGPUDevice)(nil).GetSupportedPerformanceStates))
}

// GetSupportedVgpus mocks base method.
func (m *MockGPUDevice) GetSupportedVgpus() ([]nvml.VgpuTypeId, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSupportedVgpus")
	ret0, _ := ret[0].([]nvml.VgpuTypeId)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetSupportedVgpus indicates an expected call of GetSupportedVgpus.
func (mr *MockGPUDeviceMockRecorder) GetSupportedVgpus() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSupportedVgpus", reflect.TypeOf((*MockGPUDevice)(nil).GetSupportedVgpus))
}

// GetTargetFanSpeed mocks base method.
func (m *MockGPUDevice) GetTargetFanSpeed(arg0 int) (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTargetFanSpeed", arg0)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetTargetFanSpeed indicates an expected call of GetTargetFanSpeed.
func (mr *MockGPUDeviceMockRecorder) GetTargetFanSpeed(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTargetFanSpeed", reflect.TypeOf((*MockGPUDevice)(nil).GetTargetFanSpeed), arg0)
}

// GetTemperature mocks base method.
func (m *MockGPUDevice) GetTemperature(arg0 nvml.TemperatureSensors) (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemperature", arg0)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetTemperature indicates an expected call of GetTemperature.
func (mr *MockGPUDeviceMockRecorder) GetTemperature(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemperature", reflect.TypeOf((*MockGPUDevice)(nil).GetTemperature), arg0)
}

// GetTemperatureThreshold mocks base method.
func (m *MockGPUDevice) GetTemperatureThreshold(arg0 nvml.TemperatureThresholds) (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemperatureThreshold", arg0)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetTemperatureThreshold indicates an expected call of GetTemperatureThreshold.
func (mr *MockGPUDeviceMockRecorder) GetTemperatureThreshold(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemperatureThreshold", reflect.TypeOf((*MockGPUDevice)(nil).GetTemperatureThreshold), arg0)
}

// GetThermalSettings mocks base method.
func (m *MockGPUDevice) GetThermalSettings(arg0 uint32) (nvml.GpuThermalSettings, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThermalSettings", arg0)
	ret0, _ := ret[0].(nvml.GpuThermalSettings)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetThermalSettings indicates an expected call of GetThermalSettings.
func (mr *MockGPUDeviceMockRecorder) GetThermalSettings(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThermalSettings", reflect.TypeOf((*MockGPUDevice)(nil).GetThermalSettings), arg0)
}

// GetTopologyCommonAncestor mocks base method.
func (m *MockGPUDevice) GetTopologyCommonAncestor(arg0 nvml.Device) (nvml.GpuTopologyLevel, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTopologyCommonAncestor", arg0)
	ret0, _ := ret[0].(nvml.GpuTopologyLevel)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetTopologyCommonAncestor indicates an expected call of GetTopologyCommonAncestor.
func (mr *MockGPUDeviceMockRecorder) GetTopologyCommonAncestor(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTopologyCommonAncestor", reflect.TypeOf((*MockGPUDevice)(nil).GetTopologyCommonAncestor), arg0)
}

// GetTopologyNearestGpus mocks base method.
func (m *MockGPUDevice) GetTopologyNearestGpus(arg0 nvml.GpuTopologyLevel) ([]nvml.Device, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTopologyNearestGpus", arg0)
	ret0, _ := ret[0].([]nvml.Device)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetTopologyNearestGpus indicates an expected call of GetTopologyNearestGpus.
func (mr *MockGPUDeviceMockRecorder) GetTopologyNearestGpus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTopologyNearestGpus", reflect.TypeOf((*MockGPUDevice)(nil).GetTopologyNearestGpus), arg0)
}

// GetTotalEccErrors mocks base method.
func (m *MockGPUDevice) GetTotalEccErrors(arg0 nvml.MemoryErrorType, arg1 nvml.EccCounterType) (uint64, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTotalEccErrors", arg0, arg1)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetTotalEccErrors indicates an expected call of GetTotalEccErrors.
func (mr *MockGPUDeviceMockRecorder) GetTotalEccErrors(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTotalEccErrors", reflect.TypeOf((*MockGPUDevice)(nil).GetTotalEccErrors), arg0, arg1)
}

// GetTotalEnergyConsumption mocks base method.
func (m *MockGPUDevice) GetTotalEnergyConsumption() (uint64, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTotalEnergyConsumption")
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetTotalEnergyConsumption indicates an expected call of GetTotalEnergyConsumption.
func (mr *MockGPUDeviceMockRecorder) GetTotalEnergyConsumption() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTotalEnergyConsumption", reflect.TypeOf((*MockGPUDevice)(nil).GetTotalEnergyConsumption))
}

// GetUUID mocks base method.
func (m *MockGPUDevice) GetUUID() (string, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUUID")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetUUID indicates an expected call of GetUUID.
func (mr *MockGPUDeviceMockRecorder) GetUUID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUUID", reflect.TypeOf((*MockGPUDevice)(nil).GetUUID))
}

// GetUtilizationRates mocks base method.
func (m *MockGPUDevice) GetUtilizationRates() (nvml.Utilization, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUtilizationRates")
	ret0, _ := ret[0].(nvml.Utilization)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetUtilizationRates indicates an expected call of GetUtilizationRates.
func (mr *MockGPUDeviceMockRecorder) GetUtilizationRates() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUtilizationRates", reflect.TypeOf((*MockGPUDevice)(nil).GetUtilizationRates))
}

// GetVbiosVersion mocks base method.
func (m *MockGPUDevice) GetVbiosVersion() (string, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVbiosVersion")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetVbiosVersion indicates an expected call of GetVbiosVersion.
func (mr *MockGPUDeviceMockRecorder) GetVbiosVersion() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVbiosVersion", reflect.TypeOf((*MockGPUDevice)(nil).GetVbiosVersion))
}

// GetVgpuCapabilities mocks base method.
func (m *MockGPUDevice) GetVgpuCapabilities(arg0 nvml.DeviceVgpuCapability) (bool, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVgpuCapabilities", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetVgpuCapabilities indicates an expected call of GetVgpuCapabilities.
func (mr *MockGPUDeviceMockRecorder) GetVgpuCapabilities(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuCapabilities", reflect.TypeOf((*MockGPUDevice)(nil).GetVgpuCapabilities), arg0)
}

// GetVgpuHeterogeneousMode mocks base method.
func (m *MockGPUDevice) GetVgpuHeterogeneousMode() (nvml.VgpuHeterogeneousMode, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVgpuHeterogeneousMode")
	ret0, _ := ret[0].(nvml.VgpuHeterogeneousMode)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetVgpuHeterogeneousMode indicates an expected call of GetVgpuHeterogeneousMode.
func (mr *MockGPUDeviceMockRecorder) GetVgpuHeterogeneousMode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuHeterogeneousMode", reflect.TypeOf((*MockGPUDevice)(nil).GetVgpuHeterogeneousMode))
}

// GetVgpuInstancesUtilizationInfo mocks base method.
func (m *MockGPUDevice) GetVgpuInstancesUtilizationInfo() (nvml.VgpuInstancesUtilizationInfo, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVgpuInstancesUtilizationInfo")
	ret0, _ := ret[0].(nvml.VgpuInstancesUtilizationInfo)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetVgpuInstancesUtilizationInfo indicates an expected call of GetVgpuInstancesUtilizationInfo.
func (mr *MockGPUDeviceMockRecorder) GetVgpuInstancesUtilizationInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuInstancesUtilizationInfo", reflect.TypeOf((*MockGPUDevice)(nil).GetVgpuInstancesUtilizationInfo))
}

// GetVgpuMetadata mocks base method.
func (m *MockGPUDevice) GetVgpuMetadata() (nvml.VgpuPgpuMetadata, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVgpuMetadata")
	ret0, _ := ret[0].(nvml.VgpuPgpuMetadata)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetVgpuMetadata indicates an expected call of GetVgpuMetadata.
func (mr *MockGPUDeviceMockRecorder) GetVgpuMetadata() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuMetadata", reflect.TypeOf((*MockGPUDevice)(nil).GetVgpuMetadata))
}

// GetVgpuProcessUtilization mocks base method.
func (m *MockGPUDevice) GetVgpuProcessUtilization(arg0 uint64) ([]nvml.VgpuProcessUtilizationSample, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVgpuProcessUtilization", arg0)
	ret0, _ := ret[0].([]nvml.VgpuProcessUtilizationSample)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetVgpuProcessUtilization indicates an expected call of GetVgpuProcessUtilization.
func (mr *MockGPUDeviceMockRecorder) GetVgpuProcessUtilization(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuProcessUtilization", reflect.TypeOf((*MockGPUDevice)(nil).GetVgpuProcessUtilization), arg0)
}

// GetVgpuProcessesUtilizationInfo mocks base method.
func (m *MockGPUDevice) GetVgpuProcessesUtilizationInfo() (nvml.VgpuProcessesUtilizationInfo, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVgpuProcessesUtilizationInfo")
	ret0, _ := ret[0].(nvml.VgpuProcessesUtilizationInfo)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetVgpuProcessesUtilizationInfo indicates an expected call of GetVgpuProcessesUtilizationInfo.
func (mr *MockGPUDeviceMockRecorder) GetVgpuProcessesUtilizationInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuProcessesUtilizationInfo", reflect.TypeOf((*MockGPUDevice)(nil).GetVgpuProcessesUtilizationInfo))
}

// GetVgpuSchedulerCapabilities mocks base method.
func (m *MockGPUDevice) GetVgpuSchedulerCapabilities() (nvml.VgpuSchedulerCapabilities, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVgpuSchedulerCapabilities")
	ret0, _ := ret[0].(nvml.VgpuSchedulerCapabilities)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetVgpuSchedulerCapabilities indicates an expected call of GetVgpuSchedulerCapabilities.
func (mr *MockGPUDeviceMockRecorder) GetVgpuSchedulerCapabilities() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuSchedulerCapabilities", reflect.TypeOf((*MockGPUDevice)(nil).GetVgpuSchedulerCapabilities))
}

// GetVgpuSchedulerLog mocks base method.
func (m *MockGPUDevice) GetVgpuSchedulerLog() (nvml.VgpuSchedulerLog, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVgpuSchedulerLog")
	ret0, _ := ret[0].(nvml.VgpuSchedulerLog)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetVgpuSchedulerLog indicates an expected call of GetVgpuSchedulerLog.
func (mr *MockGPUDeviceMockRecorder) GetVgpuSchedulerLog() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuSchedulerLog", reflect.TypeOf((*MockGPUDevice)(nil).GetVgpuSchedulerLog))
}

// GetVgpuSchedulerState mocks base method.
func (m *MockGPUDevice) GetVgpuSchedulerState() (nvml.VgpuSchedulerGetState, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVgpuSchedulerState")
	ret0, _ := ret[0].(nvml.VgpuSchedulerGetState)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetVgpuSchedulerState indicates an expected call of GetVgpuSchedulerState.
func (mr *MockGPUDeviceMockRecorder) GetVgpuSchedulerState() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuSchedulerState", reflect.TypeOf((*MockGPUDevice)(nil).GetVgpuSchedulerState))
}

// GetVgpuTypeCreatablePlacements mocks base method.
func (m *MockGPUDevice) GetVgpuTypeCreatablePlacements(arg0 nvml.VgpuTypeId) (nvml.VgpuPlacementList, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVgpuTypeCreatablePlacements", arg0)
	ret0, _ := ret[0].(nvml.VgpuPlacementList)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetVgpuTypeCreatablePlacements indicates an expected call of GetVgpuTypeCreatablePlacements.
func (mr *MockGPUDeviceMockRecorder) GetVgpuTypeCreatablePlacements(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuTypeCreatablePlacements", reflect.TypeOf((*MockGPUDevice)(nil).GetVgpuTypeCreatablePlacements), arg0)
}

// GetVgpuTypeSupportedPlacements mocks base method.
func (m *MockGPUDevice) GetVgpuTypeSupportedPlacements(arg0 nvml.VgpuTypeId) (nvml.VgpuPlacementList, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVgpuTypeSupportedPlacements", arg0)
	ret0, _ := ret[0].(nvml.VgpuPlacementList)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetVgpuTypeSupportedPlacements indicates an expected call of GetVgpuTypeSupportedPlacements.
func (mr *MockGPUDeviceMockRecorder) GetVgpuTypeSupportedPlacements(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuTypeSupportedPlacements", reflect.TypeOf((*MockGPUDevice)(nil).GetVgpuTypeSupportedPlacements), arg0)
}

// GetVgpuUtilization mocks base method.
func (m *MockGPUDevice) GetVgpuUtilization(arg0 uint64) (nvml.ValueType, []nvml.VgpuInstanceUtilizationSample, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVgpuUtilization", arg0)
	ret0, _ := ret[0].(nvml.ValueType)
	ret1, _ := ret[1].([]nvml.VgpuInstanceUtilizationSample)
	ret2, _ := ret[2].(nvml.Return)
	return ret0, ret1, ret2
}

// GetVgpuUtilization indicates an expected call of GetVgpuUtilization.
func (mr *MockGPUDeviceMockRecorder) GetVgpuUtilization(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVgpuUtilization", reflect.TypeOf((*MockGPUDevice)(nil).GetVgpuUtilization), arg0)
}

// GetViolationStatus mocks base method.
func (m *MockGPUDevice) GetViolationStatus(arg0 nvml.PerfPolicyType) (nvml.ViolationTime, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetViolationStatus", arg0)
	ret0, _ := ret[0].(nvml.ViolationTime)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetViolationStatus indicates an expected call of GetViolationStatus.
func (mr *MockGPUDeviceMockRecorder) GetViolationStatus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetViolationStatus", reflect.TypeOf((*MockGPUDevice)(nil).GetViolationStatus), arg0)
}

// GetVirtualizationMode mocks base method.
func (m *MockGPUDevice) GetVirtualizationMode() (nvml.GpuVirtualizationMode, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVirtualizationMode")
	ret0, _ := ret[0].(nvml.GpuVirtualizationMode)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GetVirtualizationMode indicates an expected call of GetVirtualizationMode.
func (mr *MockGPUDeviceMockRecorder) GetVirtualizationMode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualizationMode", reflect.TypeOf((*MockGPUDevice)(nil).GetVirtualizationMode))
}

// GpmMigSampleGet mocks base method.
func (m *MockGPUDevice) GpmMigSampleGet(arg0 int, arg1 nvml.GpmSample) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GpmMigSampleGet", arg0, arg1)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// GpmMigSampleGet indicates an expected call of GpmMigSampleGet.
func (mr *MockGPUDeviceMockRecorder) GpmMigSampleGet(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GpmMigSampleGet", reflect.TypeOf((*MockGPUDevice)(nil).GpmMigSampleGet), arg0, arg1)
}

// GpmQueryDeviceSupport mocks base method.
func (m *MockGPUDevice) GpmQueryDeviceSupport() (nvml.GpmSupport, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GpmQueryDeviceSupport")
	ret0, _ := ret[0].(nvml.GpmSupport)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GpmQueryDeviceSupport indicates an expected call of GpmQueryDeviceSupport.
func (mr *MockGPUDeviceMockRecorder) GpmQueryDeviceSupport() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GpmQueryDeviceSupport", reflect.TypeOf((*MockGPUDevice)(nil).GpmQueryDeviceSupport))
}

// GpmQueryDeviceSupportV mocks base method.
func (m *MockGPUDevice) GpmQueryDeviceSupportV() nvml.GpmSupportV {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GpmQueryDeviceSupportV")
	ret0, _ := ret[0].(nvml.GpmSupportV)
	return ret0
}

// GpmQueryDeviceSupportV indicates an expected call of GpmQueryDeviceSupportV.
func (mr *MockGPUDeviceMockRecorder) GpmQueryDeviceSupportV() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GpmQueryDeviceSupportV", reflect.TypeOf((*MockGPUDevice)(nil).GpmQueryDeviceSupportV))
}

// GpmQueryIfStreamingEnabled mocks base method.
func (m *MockGPUDevice) GpmQueryIfStreamingEnabled() (uint32, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GpmQueryIfStreamingEnabled")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// GpmQueryIfStreamingEnabled indicates an expected call of GpmQueryIfStreamingEnabled.
func (mr *MockGPUDeviceMockRecorder) GpmQueryIfStreamingEnabled() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GpmQueryIfStreamingEnabled", reflect.TypeOf((*MockGPUDevice)(nil).GpmQueryIfStreamingEnabled))
}

// GpmSampleGet mocks base method.
func (m *MockGPUDevice) GpmSampleGet(arg0 nvml.GpmSample) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GpmSampleGet", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// GpmSampleGet indicates an expected call of GpmSampleGet.
func (mr *MockGPUDeviceMockRecorder) GpmSampleGet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GpmSampleGet", reflect.TypeOf((*MockGPUDevice)(nil).GpmSampleGet), arg0)
}

// GpmSetStreamingEnabled mocks base method.
func (m *MockGPUDevice) GpmSetStreamingEnabled(arg0 uint32) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GpmSetStreamingEnabled", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// GpmSetStreamingEnabled indicates an expected call of GpmSetStreamingEnabled.
func (mr *MockGPUDeviceMockRecorder) GpmSetStreamingEnabled(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GpmSetStreamingEnabled", reflect.TypeOf((*MockGPUDevice)(nil).GpmSetStreamingEnabled), arg0)
}

// IsMigDeviceHandle mocks base method.
func (m *MockGPUDevice) IsMigDeviceHandle() (bool, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsMigDeviceHandle")
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// IsMigDeviceHandle indicates an expected call of IsMigDeviceHandle.
func (mr *MockGPUDeviceMockRecorder) IsMigDeviceHandle() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsMigDeviceHandle", reflect.TypeOf((*MockGPUDevice)(nil).IsMigDeviceHandle))
}

// OnSameBoard mocks base method.
func (m *MockGPUDevice) OnSameBoard(arg0 nvml.Device) (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnSameBoard", arg0)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// OnSameBoard indicates an expected call of OnSameBoard.
func (mr *MockGPUDeviceMockRecorder) OnSameBoard(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnSameBoard", reflect.TypeOf((*MockGPUDevice)(nil).OnSameBoard), arg0)
}

// RegisterEvents mocks base method.
func (m *MockGPUDevice) RegisterEvents(arg0 uint64, arg1 nvml.EventSet) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterEvents", arg0, arg1)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// RegisterEvents indicates an expected call of RegisterEvents.
func (mr *MockGPUDeviceMockRecorder) RegisterEvents(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterEvents", reflect.TypeOf((*MockGPUDevice)(nil).RegisterEvents), arg0, arg1)
}

// ResetApplicationsClocks mocks base method.
func (m *MockGPUDevice) ResetApplicationsClocks() nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetApplicationsClocks")
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// ResetApplicationsClocks indicates an expected call of ResetApplicationsClocks.
func (mr *MockGPUDeviceMockRecorder) ResetApplicationsClocks() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetApplicationsClocks", reflect.TypeOf((*MockGPUDevice)(nil).ResetApplicationsClocks))
}

// ResetGpuLockedClocks mocks base method.
func (m *MockGPUDevice) ResetGpuLockedClocks() nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetGpuLockedClocks")
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// ResetGpuLockedClocks indicates an expected call of ResetGpuLockedClocks.
func (mr *MockGPUDeviceMockRecorder) ResetGpuLockedClocks() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetGpuLockedClocks", reflect.TypeOf((*MockGPUDevice)(nil).ResetGpuLockedClocks))
}

// ResetMemoryLockedClocks mocks base method.
func (m *MockGPUDevice) ResetMemoryLockedClocks() nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetMemoryLockedClocks")
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// ResetMemoryLockedClocks indicates an expected call of ResetMemoryLockedClocks.
func (mr *MockGPUDeviceMockRecorder) ResetMemoryLockedClocks() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetMemoryLockedClocks", reflect.TypeOf((*MockGPUDevice)(nil).ResetMemoryLockedClocks))
}

// ResetNvLinkErrorCounters mocks base method.
func (m *MockGPUDevice) ResetNvLinkErrorCounters(arg0 int) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetNvLinkErrorCounters", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// ResetNvLinkErrorCounters indicates an expected call of ResetNvLinkErrorCounters.
func (mr *MockGPUDeviceMockRecorder) ResetNvLinkErrorCounters(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNvLinkErrorCounters", reflect.TypeOf((*MockGPUDevice)(nil).ResetNvLinkErrorCounters), arg0)
}

// ResetNvLinkUtilizationCounter mocks base method.
func (m *MockGPUDevice) ResetNvLinkUtilizationCounter(arg0, arg1 int) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetNvLinkUtilizationCounter", arg0, arg1)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// ResetNvLinkUtilizationCounter indicates an expected call of ResetNvLinkUtilizationCounter.
func (mr *MockGPUDeviceMockRecorder) ResetNvLinkUtilizationCounter(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNvLinkUtilizationCounter", reflect.TypeOf((*MockGPUDevice)(nil).ResetNvLinkUtilizationCounter), arg0, arg1)
}

// SetAPIRestriction mocks base method.
func (m *MockGPUDevice) SetAPIRestriction(arg0 nvml.RestrictedAPI, arg1 nvml.EnableState) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAPIRestriction", arg0, arg1)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetAPIRestriction indicates an expected call of SetAPIRestriction.
func (mr *MockGPUDeviceMockRecorder) SetAPIRestriction(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAPIRestriction", reflect.TypeOf((*MockGPUDevice)(nil).SetAPIRestriction), arg0, arg1)
}

// SetAccountingMode mocks base method.
func (m *MockGPUDevice) SetAccountingMode(arg0 nvml.EnableState) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAccountingMode", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetAccountingMode indicates an expected call of SetAccountingMode.
func (mr *MockGPUDeviceMockRecorder) SetAccountingMode(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAccountingMode", reflect.TypeOf((*MockGPUDevice)(nil).SetAccountingMode), arg0)
}

// SetApplicationsClocks mocks base method.
func (m *MockGPUDevice) SetApplicationsClocks(arg0, arg1 uint32) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetApplicationsClocks", arg0, arg1)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetApplicationsClocks indicates an expected call of SetApplicationsClocks.
func (mr *MockGPUDeviceMockRecorder) SetApplicationsClocks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetApplicationsClocks", reflect.TypeOf((*MockGPUDevice)(nil).SetApplicationsClocks), arg0, arg1)
}

// SetAutoBoostedClocksEnabled mocks base method.
func (m *MockGPUDevice) SetAutoBoostedClocksEnabled(arg0 nvml.EnableState) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAutoBoostedClocksEnabled", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetAutoBoostedClocksEnabled indicates an expected call of SetAutoBoostedClocksEnabled.
func (mr *MockGPUDeviceMockRecorder) SetAutoBoostedClocksEnabled(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAutoBoostedClocksEnabled", reflect.TypeOf((*MockGPUDevice)(nil).SetAutoBoostedClocksEnabled), arg0)
}

// SetComputeMode mocks base method.
func (m *MockGPUDevice) SetComputeMode(arg0 nvml.ComputeMode) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetComputeMode", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetComputeMode indicates an expected call of SetComputeMode.
func (mr *MockGPUDeviceMockRecorder) SetComputeMode(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetComputeMode", reflect.TypeOf((*MockGPUDevice)(nil).SetComputeMode), arg0)
}

// SetConfComputeUnprotectedMemSize mocks base method.
func (m *MockGPUDevice) SetConfComputeUnprotectedMemSize(arg0 uint64) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetConfComputeUnprotectedMemSize", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetConfComputeUnprotectedMemSize indicates an expected call of SetConfComputeUnprotectedMemSize.
func (mr *MockGPUDeviceMockRecorder) SetConfComputeUnprotectedMemSize(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConfComputeUnprotectedMemSize", reflect.TypeOf((*MockGPUDevice)(nil).SetConfComputeUnprotectedMemSize), arg0)
}

// SetCpuAffinity mocks base method.
func (m *MockGPUDevice) SetCpuAffinity() nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetCpuAffinity")
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetCpuAffinity indicates an expected call of SetCpuAffinity.
func (mr *MockGPUDeviceMockRecorder) SetCpuAffinity() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCpuAffinity", reflect.TypeOf((*MockGPUDevice)(nil).SetCpuAffinity))
}

// SetDefaultAutoBoostedClocksEnabled mocks base method.
func (m *MockGPUDevice) SetDefaultAutoBoostedClocksEnabled(arg0 nvml.EnableState, arg1 uint32) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetDefaultAutoBoostedClocksEnabled", arg0, arg1)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetDefaultAutoBoostedClocksEnabled indicates an expected call of SetDefaultAutoBoostedClocksEnabled.
func (mr *MockGPUDeviceMockRecorder) SetDefaultAutoBoostedClocksEnabled(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultAutoBoostedClocksEnabled", reflect.TypeOf((*MockGPUDevice)(nil).SetDefaultAutoBoostedClocksEnabled), arg0, arg1)
}

// SetDefaultFanSpeed_v2 mocks base method.
func (m *MockGPUDevice) SetDefaultFanSpeed_v2(arg0 int) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetDefaultFanSpeed_v2", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetDefaultFanSpeed_v2 indicates an expected call of SetDefaultFanSpeed_v2.
func (mr *MockGPUDeviceMockRecorder) SetDefaultFanSpeed_v2(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultFanSpeed_v2", reflect.TypeOf((*MockGPUDevice)(nil).SetDefaultFanSpeed_v2), arg0)
}

// SetDriverModel mocks base method.
func (m *MockGPUDevice) SetDriverModel(arg0 nvml.DriverModel, arg1 uint32) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetDriverModel", arg0, arg1)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetDriverModel indicates an expected call of SetDriverModel.
func (mr *MockGPUDeviceMockRecorder) SetDriverModel(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDriverModel", reflect.TypeOf((*MockGPUDevice)(nil).SetDriverModel), arg0, arg1)
}

// SetEccMode mocks base method.
func (m *MockGPUDevice) SetEccMode(arg0 nvml.EnableState) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetEccMode", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetEccMode indicates an expected call of SetEccMode.
func (mr *MockGPUDeviceMockRecorder) SetEccMode(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEccMode", reflect.TypeOf((*MockGPUDevice)(nil).SetEccMode), arg0)
}

// SetFanControlPolicy mocks base method.
func (m *MockGPUDevice) SetFanControlPolicy(arg0 int, arg1 nvml.FanControlPolicy) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetFanControlPolicy", arg0, arg1)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetFanControlPolicy indicates an expected call of SetFanControlPolicy.
func (mr *MockGPUDeviceMockRecorder) SetFanControlPolicy(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFanControlPolicy", reflect.TypeOf((*MockGPUDevice)(nil).SetFanControlPolicy), arg0, arg1)
}

// SetFanSpeed_v2 mocks base method.
func (m *MockGPUDevice) SetFanSpeed_v2(arg0, arg1 int) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetFanSpeed_v2", arg0, arg1)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetFanSpeed_v2 indicates an expected call of SetFanSpeed_v2.
func (mr *MockGPUDeviceMockRecorder) SetFanSpeed_v2(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFanSpeed_v2", reflect.TypeOf((*MockGPUDevice)(nil).SetFanSpeed_v2), arg0, arg1)
}

// SetGpcClkVfOffset mocks base method.
func (m *MockGPUDevice) SetGpcClkVfOffset(arg0 int) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetGpcClkVfOffset", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetGpcClkVfOffset indicates an expected call of SetGpcClkVfOffset.
func (mr *MockGPUDeviceMockRecorder) SetGpcClkVfOffset(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGpcClkVfOffset", reflect.TypeOf((*MockGPUDevice)(nil).SetGpcClkVfOffset), arg0)
}

// SetGpuLockedClocks mocks base method.
func (m *MockGPUDevice) SetGpuLockedClocks(arg0, arg1 uint32) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetGpuLockedClocks", arg0, arg1)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetGpuLockedClocks indicates an expected call of SetGpuLockedClocks.
func (mr *MockGPUDeviceMockRecorder) SetGpuLockedClocks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGpuLockedClocks", reflect.TypeOf((*MockGPUDevice)(nil).SetGpuLockedClocks), arg0, arg1)
}

// SetGpuOperationMode mocks base method.
func (m *MockGPUDevice) SetGpuOperationMode(arg0 nvml.GpuOperationMode) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetGpuOperationMode", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetGpuOperationMode indicates an expected call of SetGpuOperationMode.
func (mr *MockGPUDeviceMockRecorder) SetGpuOperationMode(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGpuOperationMode", reflect.TypeOf((*MockGPUDevice)(nil).SetGpuOperationMode), arg0)
}

// SetMemClkVfOffset mocks base method.
func (m *MockGPUDevice) SetMemClkVfOffset(arg0 int) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetMemClkVfOffset", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetMemClkVfOffset indicates an expected call of SetMemClkVfOffset.
func (mr *MockGPUDeviceMockRecorder) SetMemClkVfOffset(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMemClkVfOffset", reflect.TypeOf((*MockGPUDevice)(nil).SetMemClkVfOffset), arg0)
}

// SetMemoryLockedClocks mocks base method.
func (m *MockGPUDevice) SetMemoryLockedClocks(arg0, arg1 uint32) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetMemoryLockedClocks", arg0, arg1)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetMemoryLockedClocks indicates an expected call of SetMemoryLockedClocks.
func (mr *MockGPUDeviceMockRecorder) SetMemoryLockedClocks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMemoryLockedClocks", reflect.TypeOf((*MockGPUDevice)(nil).SetMemoryLockedClocks), arg0, arg1)
}

// SetMigMode mocks base method.
func (m *MockGPUDevice) SetMigMode(arg0 int) (nvml.Return, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetMigMode", arg0)
	ret0, _ := ret[0].(nvml.Return)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// SetMigMode indicates an expected call of SetMigMode.
func (mr *MockGPUDeviceMockRecorder) SetMigMode(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMigMode", reflect.TypeOf((*MockGPUDevice)(nil).SetMigMode), arg0)
}

// SetNvLinkDeviceLowPowerThreshold mocks base method.
func (m *MockGPUDevice) SetNvLinkDeviceLowPowerThreshold(arg0 *nvml.NvLinkPowerThres) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetNvLinkDeviceLowPowerThreshold", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetNvLinkDeviceLowPowerThreshold indicates an expected call of SetNvLinkDeviceLowPowerThreshold.
func (mr *MockGPUDeviceMockRecorder) SetNvLinkDeviceLowPowerThreshold(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNvLinkDeviceLowPowerThreshold", reflect.TypeOf((*MockGPUDevice)(nil).SetNvLinkDeviceLowPowerThreshold), arg0)
}

// SetNvLinkUtilizationControl mocks base method.
func (m *MockGPUDevice) SetNvLinkUtilizationControl(arg0, arg1 int, arg2 *nvml.NvLinkUtilizationControl, arg3 bool) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetNvLinkUtilizationControl", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetNvLinkUtilizationControl indicates an expected call of SetNvLinkUtilizationControl.
func (mr *MockGPUDeviceMockRecorder) SetNvLinkUtilizationControl(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNvLinkUtilizationControl", reflect.TypeOf((*MockGPUDevice)(nil).SetNvLinkUtilizationControl), arg0, arg1, arg2, arg3)
}

// SetPersistenceMode mocks base method.
func (m *MockGPUDevice) SetPersistenceMode(arg0 nvml.EnableState) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPersistenceMode", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetPersistenceMode indicates an expected call of SetPersistenceMode.
func (mr *MockGPUDeviceMockRecorder) SetPersistenceMode(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPersistenceMode", reflect.TypeOf((*MockGPUDevice)(nil).SetPersistenceMode), arg0)
}

// SetPowerManagementLimit mocks base method.
func (m *MockGPUDevice) SetPowerManagementLimit(arg0 uint32) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPowerManagementLimit", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetPowerManagementLimit indicates an expected call of SetPowerManagementLimit.
func (mr *MockGPUDeviceMockRecorder) SetPowerManagementLimit(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPowerManagementLimit", reflect.TypeOf((*MockGPUDevice)(nil).SetPowerManagementLimit), arg0)
}

// SetPowerManagementLimit_v2 mocks base method.
func (m *MockGPUDevice) SetPowerManagementLimit_v2(arg0 *nvml.PowerValue_v2) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPowerManagementLimit_v2", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetPowerManagementLimit_v2 indicates an expected call of SetPowerManagementLimit_v2.
func (mr *MockGPUDeviceMockRecorder) SetPowerManagementLimit_v2(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPowerManagementLimit_v2", reflect.TypeOf((*MockGPUDevice)(nil).SetPowerManagementLimit_v2), arg0)
}

// SetTemperatureThreshold mocks base method.
func (m *MockGPUDevice) SetTemperatureThreshold(arg0 nvml.TemperatureThresholds, arg1 int) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetTemperatureThreshold", arg0, arg1)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetTemperatureThreshold indicates an expected call of SetTemperatureThreshold.
func (mr *MockGPUDeviceMockRecorder) SetTemperatureThreshold(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTemperatureThreshold", reflect.TypeOf((*MockGPUDevice)(nil).SetTemperatureThreshold), arg0, arg1)
}

// SetVgpuCapabilities mocks base method.
func (m *MockGPUDevice) SetVgpuCapabilities(arg0 nvml.DeviceVgpuCapability, arg1 nvml.EnableState) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetVgpuCapabilities", arg0, arg1)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetVgpuCapabilities indicates an expected call of SetVgpuCapabilities.
func (mr *MockGPUDeviceMockRecorder) SetVgpuCapabilities(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVgpuCapabilities", reflect.TypeOf((*MockGPUDevice)(nil).SetVgpuCapabilities), arg0, arg1)
}

// SetVgpuHeterogeneousMode mocks base method.
func (m *MockGPUDevice) SetVgpuHeterogeneousMode(arg0 nvml.VgpuHeterogeneousMode) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetVgpuHeterogeneousMode", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetVgpuHeterogeneousMode indicates an expected call of SetVgpuHeterogeneousMode.
func (mr *MockGPUDeviceMockRecorder) SetVgpuHeterogeneousMode(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVgpuHeterogeneousMode", reflect.TypeOf((*MockGPUDevice)(nil).SetVgpuHeterogeneousMode), arg0)
}

// SetVgpuSchedulerState mocks base method.
func (m *MockGPUDevice) SetVgpuSchedulerState(arg0 *nvml.VgpuSchedulerSetState) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetVgpuSchedulerState", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetVgpuSchedulerState indicates an expected call of SetVgpuSchedulerState.
func (mr *MockGPUDeviceMockRecorder) SetVgpuSchedulerState(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVgpuSchedulerState", reflect.TypeOf((*MockGPUDevice)(nil).SetVgpuSchedulerState), arg0)
}

// SetVirtualizationMode mocks base method.
func (m *MockGPUDevice) SetVirtualizationMode(arg0 nvml.GpuVirtualizationMode) nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetVirtualizationMode", arg0)
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// SetVirtualizationMode indicates an expected call of SetVirtualizationMode.
func (mr *MockGPUDeviceMockRecorder) SetVirtualizationMode(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVirtualizationMode", reflect.TypeOf((*MockGPUDevice)(nil).SetVirtualizationMode), arg0)
}

// ValidateInforom mocks base method.
func (m *MockGPUDevice) ValidateInforom() nvml.Return {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateInforom")
	ret0, _ := ret[0].(nvml.Return)
	return ret0
}

// ValidateInforom indicates an expected call of ValidateInforom.
func (mr *MockGPUDeviceMockRecorder) ValidateInforom() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateInforom", reflect.TypeOf((*MockGPUDevice)(nil).ValidateInforom))
}

// VgpuTypeGetMaxInstances mocks base method.
func (m *MockGPUDevice) VgpuTypeGetMaxInstances(arg0 nvml.VgpuTypeId) (int, nvml.Return) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VgpuTypeGetMaxInstances", arg0)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(nvml.Return)
	return ret0, ret1
}

// VgpuTypeGetMaxInstances indicates an expected call of VgpuTypeGetMaxInstances.
func (mr *MockGPUDeviceMockRecorder) VgpuTypeGetMaxInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VgpuTypeGetMaxInstances", reflect.TypeOf((*MockGPUDevice)(nil).VgpuTypeGetMaxInstances), arg0)
}
