mirror of
https://github.com/iperov/DeepFaceLab.git
synced 2025-08-14 10:46:59 -07:00
removing trailing spaces
This commit is contained in:
iperov
parent
fa4e579b95
commit
a3df04999c
61 changed files with 2110 additions and 2103 deletions
|
|
@ -61,7 +61,7 @@ def _scale_filters(filters, variance):
|
|||
def CAGenerateWeights ( shape, floatx, data_format, eps_std=0.05, seed=None ):
|
||||
if seed is not None:
|
||||
np.random.seed(seed)
|
||||
|
||||
|
||||
fan_in, fan_out = _compute_fans(shape, data_format)
|
||||
variance = 2 / fan_in
|
||||
|
||||
|
|
@ -109,4 +109,4 @@ def CAGenerateWeights ( shape, floatx, data_format, eps_std=0.05, seed=None ):
|
|||
# Format of array is now: filters, stack, row, column
|
||||
init = np.array(init)
|
||||
init = _scale_filters(init, variance)
|
||||
return init.transpose(transpose_dimensions)
|
||||
return init.transpose(transpose_dimensions)
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
from .nnlib import nnlib
|
||||
from .nnlib import nnlib
|
||||
|
|
|
|||
111
nnlib/device.py
111
nnlib/device.py
|
|
@ -5,11 +5,11 @@ from .pynvml import *
|
|||
|
||||
#you can set DFL_TF_MIN_REQ_CAP manually for your build
|
||||
#the reason why we cannot check tensorflow.version is it requires import tensorflow
|
||||
tf_min_req_cap = int(os.environ.get("DFL_TF_MIN_REQ_CAP", 35))
|
||||
|
||||
tf_min_req_cap = int(os.environ.get("DFL_TF_MIN_REQ_CAP", 35))
|
||||
|
||||
class device:
|
||||
backend = None
|
||||
class Config():
|
||||
class Config():
|
||||
force_gpu_idx = -1
|
||||
multi_gpu = False
|
||||
force_gpu_idxs = None
|
||||
|
|
@ -22,36 +22,36 @@ class device:
|
|||
use_fp16 = False
|
||||
cpu_only = False
|
||||
backend = None
|
||||
def __init__ (self, force_gpu_idx = -1,
|
||||
multi_gpu = False,
|
||||
force_gpu_idxs = None,
|
||||
def __init__ (self, force_gpu_idx = -1,
|
||||
multi_gpu = False,
|
||||
force_gpu_idxs = None,
|
||||
choose_worst_gpu = False,
|
||||
allow_growth = True,
|
||||
use_fp16 = False,
|
||||
cpu_only = False,
|
||||
**in_options):
|
||||
|
||||
|
||||
self.backend = device.backend
|
||||
self.use_fp16 = use_fp16
|
||||
self.cpu_only = cpu_only
|
||||
|
||||
|
||||
if not self.cpu_only:
|
||||
self.cpu_only = (self.backend == "tensorflow-cpu")
|
||||
|
||||
|
||||
if not self.cpu_only:
|
||||
self.force_gpu_idx = force_gpu_idx
|
||||
self.multi_gpu = multi_gpu
|
||||
self.force_gpu_idxs = force_gpu_idxs
|
||||
self.choose_worst_gpu = choose_worst_gpu
|
||||
self.choose_worst_gpu = choose_worst_gpu
|
||||
self.allow_growth = allow_growth
|
||||
|
||||
|
||||
self.gpu_idxs = []
|
||||
|
||||
if force_gpu_idxs is not None:
|
||||
for idx in force_gpu_idxs.split(','):
|
||||
idx = int(idx)
|
||||
if device.isValidDeviceIdx(idx):
|
||||
self.gpu_idxs.append(idx)
|
||||
self.gpu_idxs.append(idx)
|
||||
else:
|
||||
gpu_idx = force_gpu_idx if (force_gpu_idx >= 0 and device.isValidDeviceIdx(force_gpu_idx)) else device.getBestValidDeviceIdx() if not choose_worst_gpu else device.getWorstValidDeviceIdx()
|
||||
if gpu_idx != -1:
|
||||
|
|
@ -61,10 +61,10 @@ class device:
|
|||
self.multi_gpu = False
|
||||
else:
|
||||
self.gpu_idxs = [gpu_idx]
|
||||
|
||||
|
||||
self.cpu_only = (len(self.gpu_idxs) == 0)
|
||||
|
||||
|
||||
|
||||
|
||||
if not self.cpu_only:
|
||||
self.gpu_names = []
|
||||
self.gpu_compute_caps = []
|
||||
|
|
@ -78,10 +78,10 @@ class device:
|
|||
self.gpu_names = ['CPU']
|
||||
self.gpu_compute_caps = [99]
|
||||
self.gpu_vram_gb = [0]
|
||||
|
||||
|
||||
if self.cpu_only:
|
||||
self.backend = "tensorflow-cpu"
|
||||
|
||||
|
||||
@staticmethod
|
||||
def getValidDeviceIdxsEnumerator():
|
||||
if device.backend == "plaidML":
|
||||
|
|
@ -94,8 +94,8 @@ class device:
|
|||
yield gpu_idx
|
||||
elif device.backend == "tensorflow-generic":
|
||||
yield 0
|
||||
|
||||
|
||||
|
||||
|
||||
@staticmethod
|
||||
def getValidDevicesWithAtLeastTotalMemoryGB(totalmemsize_gb):
|
||||
result = []
|
||||
|
|
@ -111,9 +111,9 @@ class device:
|
|||
result.append (i)
|
||||
elif device.backend == "tensorflow-generic":
|
||||
return [0]
|
||||
|
||||
|
||||
return result
|
||||
|
||||
|
||||
@staticmethod
|
||||
def getAllDevicesIdxsList():
|
||||
if device.backend == "plaidML":
|
||||
|
|
@ -121,8 +121,8 @@ class device:
|
|||
elif device.backend == "tensorflow":
|
||||
return [ *range(nvmlDeviceGetCount() ) ]
|
||||
elif device.backend == "tensorflow-generic":
|
||||
return [0]
|
||||
|
||||
return [0]
|
||||
|
||||
@staticmethod
|
||||
def getValidDevicesIdxsWithNamesList():
|
||||
if device.backend == "plaidML":
|
||||
|
|
@ -137,17 +137,17 @@ class device:
|
|||
@staticmethod
|
||||
def getDeviceVRAMTotalGb (idx):
|
||||
if device.backend == "plaidML":
|
||||
if idx < plaidML_devices_count:
|
||||
if idx < plaidML_devices_count:
|
||||
return plaidML_devices[idx]['globalMemSize'] / (1024*1024*1024)
|
||||
elif device.backend == "tensorflow":
|
||||
if idx < nvmlDeviceGetCount():
|
||||
if idx < nvmlDeviceGetCount():
|
||||
memInfo = nvmlDeviceGetMemoryInfo( nvmlDeviceGetHandleByIndex(idx) )
|
||||
return round ( memInfo.total / (1024*1024*1024) )
|
||||
|
||||
return 0
|
||||
elif device.backend == "tensorflow-generic":
|
||||
return 2
|
||||
|
||||
|
||||
@staticmethod
|
||||
def getBestValidDeviceIdx():
|
||||
if device.backend == "plaidML":
|
||||
|
|
@ -172,7 +172,7 @@ class device:
|
|||
return idx
|
||||
elif device.backend == "tensorflow-generic":
|
||||
return 0
|
||||
|
||||
|
||||
@staticmethod
|
||||
def getWorstValidDeviceIdx():
|
||||
if device.backend == "plaidML":
|
||||
|
|
@ -197,7 +197,7 @@ class device:
|
|||
return idx
|
||||
elif device.backend == "tensorflow-generic":
|
||||
return 0
|
||||
|
||||
|
||||
@staticmethod
|
||||
def isValidDeviceIdx(idx):
|
||||
if device.backend == "plaidML":
|
||||
|
|
@ -206,11 +206,11 @@ class device:
|
|||
return idx in [*device.getValidDeviceIdxsEnumerator()]
|
||||
elif device.backend == "tensorflow-generic":
|
||||
return (idx == 0)
|
||||
|
||||
|
||||
@staticmethod
|
||||
def getDeviceIdxsEqualModel(idx):
|
||||
if device.backend == "plaidML":
|
||||
result = []
|
||||
result = []
|
||||
idx_name = plaidML_devices[idx]['description']
|
||||
for i in device.getValidDeviceIdxsEnumerator():
|
||||
if plaidML_devices[i]['description'] == idx_name:
|
||||
|
|
@ -218,7 +218,7 @@ class device:
|
|||
|
||||
return result
|
||||
elif device.backend == "tensorflow":
|
||||
result = []
|
||||
result = []
|
||||
idx_name = nvmlDeviceGetName(nvmlDeviceGetHandleByIndex(idx)).decode()
|
||||
for i in device.getValidDeviceIdxsEnumerator():
|
||||
if nvmlDeviceGetName(nvmlDeviceGetHandleByIndex(i)).decode() == idx_name:
|
||||
|
|
@ -226,60 +226,60 @@ class device:
|
|||
|
||||
return result
|
||||
elif device.backend == "tensorflow-generic":
|
||||
return [0] if idx == 0 else []
|
||||
|
||||
return [0] if idx == 0 else []
|
||||
|
||||
@staticmethod
|
||||
def getDeviceName (idx):
|
||||
if device.backend == "plaidML":
|
||||
if idx < plaidML_devices_count:
|
||||
if idx < plaidML_devices_count:
|
||||
return plaidML_devices[idx]['description']
|
||||
elif device.backend == "tensorflow":
|
||||
if idx < nvmlDeviceGetCount():
|
||||
if idx < nvmlDeviceGetCount():
|
||||
return nvmlDeviceGetName(nvmlDeviceGetHandleByIndex(idx)).decode()
|
||||
elif device.backend == "tensorflow-generic":
|
||||
if idx == 0:
|
||||
return "Generic GeForce GPU"
|
||||
|
||||
|
||||
return None
|
||||
|
||||
|
||||
@staticmethod
|
||||
def getDeviceID (idx):
|
||||
if device.backend == "plaidML":
|
||||
if idx < plaidML_devices_count:
|
||||
if idx < plaidML_devices_count:
|
||||
return plaidML_devices[idx]['id'].decode()
|
||||
|
||||
return None
|
||||
|
||||
return None
|
||||
|
||||
@staticmethod
|
||||
def getDeviceComputeCapability(idx):
|
||||
result = 0
|
||||
if device.backend == "plaidML":
|
||||
return 99
|
||||
elif device.backend == "tensorflow":
|
||||
if idx < nvmlDeviceGetCount():
|
||||
if idx < nvmlDeviceGetCount():
|
||||
result = nvmlDeviceGetCudaComputeCapability(nvmlDeviceGetHandleByIndex(idx))
|
||||
elif device.backend == "tensorflow-generic":
|
||||
return 99 if idx == 0 else 0
|
||||
|
||||
return 99 if idx == 0 else 0
|
||||
|
||||
return result[0] * 10 + result[1]
|
||||
|
||||
|
||||
|
||||
force_plaidML = os.environ.get("DFL_FORCE_PLAIDML", "0") == "1" #for OpenCL build , forcing using plaidML even if NVIDIA found
|
||||
force_tf_cpu = os.environ.get("DFL_FORCE_TF_CPU", "0") == "1" #for OpenCL build , forcing using tf-cpu if plaidML failed
|
||||
has_nvml = False
|
||||
has_nvml_cap = False
|
||||
|
||||
#use DFL_FORCE_HAS_NVIDIA_DEVICE=1 if
|
||||
#use DFL_FORCE_HAS_NVIDIA_DEVICE=1 if
|
||||
#- your NVIDIA cannot be seen by OpenCL
|
||||
#- CUDA build of DFL
|
||||
has_nvidia_device = os.environ.get("DFL_FORCE_HAS_NVIDIA_DEVICE", "0") == "1"
|
||||
has_nvidia_device = os.environ.get("DFL_FORCE_HAS_NVIDIA_DEVICE", "0") == "1"
|
||||
|
||||
plaidML_devices = []
|
||||
|
||||
# Using plaidML OpenCL backend to determine system devices and has_nvidia_device
|
||||
try:
|
||||
try:
|
||||
os.environ['PLAIDML_EXPERIMENTAL'] = 'false' #this enables work plaidML without run 'plaidml-setup'
|
||||
import plaidml
|
||||
import plaidml
|
||||
ctx = plaidml.Context()
|
||||
for d in plaidml.devices(ctx, return_all=True)[0]:
|
||||
details = json.loads(d.details)
|
||||
|
|
@ -288,13 +288,13 @@ try:
|
|||
if 'nvidia' in details['vendor'].lower():
|
||||
has_nvidia_device = True
|
||||
plaidML_devices += [ {'id':d.id,
|
||||
'globalMemSize' : int(details['globalMemSize']),
|
||||
'globalMemSize' : int(details['globalMemSize']),
|
||||
'description' : d.description.decode()
|
||||
}]
|
||||
ctx.shutdown()
|
||||
except:
|
||||
pass
|
||||
|
||||
|
||||
plaidML_devices_count = len(plaidML_devices)
|
||||
|
||||
#choosing backend
|
||||
|
|
@ -306,11 +306,11 @@ if device.backend is None and not force_tf_cpu:
|
|||
nvmlInit()
|
||||
has_nvml = True
|
||||
device.backend = "tensorflow" #set tensorflow backend in order to use device.*device() functions
|
||||
|
||||
|
||||
gpu_idxs = device.getAllDevicesIdxsList()
|
||||
gpu_caps = np.array ( [ device.getDeviceComputeCapability(gpu_idx) for gpu_idx in gpu_idxs ] )
|
||||
|
||||
if len ( np.ndarray.flatten ( np.argwhere (gpu_caps >= tf_min_req_cap) ) ) == 0:
|
||||
|
||||
if len ( np.ndarray.flatten ( np.argwhere (gpu_caps >= tf_min_req_cap) ) ) == 0:
|
||||
if not force_plaidML:
|
||||
print ("No CUDA devices found with minimum required compute capability: %d.%d. Falling back to OpenCL mode." % (tf_min_req_cap // 10, tf_min_req_cap % 10) )
|
||||
device.backend = None
|
||||
|
|
@ -320,7 +320,7 @@ if device.backend is None and not force_tf_cpu:
|
|||
except:
|
||||
#if no NVSMI installed exception will occur
|
||||
device.backend = None
|
||||
has_nvml = False
|
||||
has_nvml = False
|
||||
|
||||
if force_plaidML or (device.backend is None and not has_nvidia_device):
|
||||
#tensorflow backend was failed without has_nvidia_device , or forcing plaidML, trying to use plaidML backend
|
||||
|
|
@ -333,7 +333,7 @@ if force_plaidML or (device.backend is None and not has_nvidia_device):
|
|||
if device.backend is None:
|
||||
if force_tf_cpu:
|
||||
device.backend = "tensorflow-cpu"
|
||||
elif not has_nvml:
|
||||
elif not has_nvml:
|
||||
if has_nvidia_device:
|
||||
#some notebook systems have NVIDIA card without NVSMI in official drivers
|
||||
#in that case considering we have system with one capable GPU and let tensorflow to choose best GPU
|
||||
|
|
@ -348,4 +348,3 @@ if device.backend is None:
|
|||
else:
|
||||
#has NVSMI, no capable CUDA-devices, also plaidML was failed, then CPU only
|
||||
device.backend = "tensorflow-cpu"
|
||||
|
||||
|
|
|
|||
|
|
@ -541,7 +541,6 @@ NLayerDiscriminator = nnlib.NLayerDiscriminator
|
|||
result = CAInitializerMPSubprocessor ( [ (i, K.int_shape(conv_weights)) for i, conv_weights in enumerate(conv_weights_list) ], K.floatx(), K.image_data_format() ).run()
|
||||
for idx, weights in result:
|
||||
K.set_value ( conv_weights_list[idx], weights )
|
||||
|
||||
nnlib.CAInitializerMP = CAInitializerMP
|
||||
|
||||
|
||||
|
|
|
|||
150
nnlib/pynvml.py
150
nnlib/pynvml.py
|
|
@ -3,7 +3,7 @@
|
|||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above copyright
|
||||
|
|
@ -18,11 +18,11 @@
|
|||
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
||||
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
||||
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
||||
# THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#####
|
||||
|
||||
|
|
@ -35,7 +35,7 @@ import sys
|
|||
import os
|
||||
import threading
|
||||
import string
|
||||
|
||||
|
||||
## C Type mappings ##
|
||||
## Enums
|
||||
_nvmlEnableState_t = c_uint
|
||||
|
|
@ -155,9 +155,9 @@ NVML_FAN_FAILED = 1
|
|||
_nvmlLedColor_t = c_uint
|
||||
NVML_LED_COLOR_GREEN = 0
|
||||
NVML_LED_COLOR_AMBER = 1
|
||||
|
||||
|
||||
_nvmlGpuOperationMode_t = c_uint
|
||||
NVML_GOM_ALL_ON = 0
|
||||
NVML_GOM_ALL_ON = 0
|
||||
NVML_GOM_COMPUTE = 1
|
||||
NVML_GOM_LOW_DP = 2
|
||||
|
||||
|
|
@ -173,7 +173,7 @@ NVML_RESTRICTED_API_COUNT = 2
|
|||
|
||||
_nvmlBridgeChipType_t = c_uint
|
||||
NVML_BRIDGE_CHIP_PLX = 0
|
||||
NVML_BRIDGE_CHIP_BRO4 = 1
|
||||
NVML_BRIDGE_CHIP_BRO4 = 1
|
||||
NVML_MAX_PHYSICAL_BRIDGE = 128
|
||||
|
||||
_nvmlValueType_t = c_uint
|
||||
|
|
@ -317,7 +317,7 @@ def _nvmlGetFunctionPointer(name):
|
|||
|
||||
if name in _nvmlGetFunctionPointer_cache:
|
||||
return _nvmlGetFunctionPointer_cache[name]
|
||||
|
||||
|
||||
libLoadLock.acquire()
|
||||
try:
|
||||
# ensure library was loaded
|
||||
|
|
@ -364,7 +364,7 @@ def nvmlFriendlyObjectToStruct(obj, model):
|
|||
class struct_c_nvmlUnit_t(Structure):
|
||||
pass # opaque handle
|
||||
c_nvmlUnit_t = POINTER(struct_c_nvmlUnit_t)
|
||||
|
||||
|
||||
class _PrintableStructure(Structure):
|
||||
"""
|
||||
Abstract class that produces nicer __str__ output than ctypes.Structure.
|
||||
|
|
@ -373,7 +373,7 @@ class _PrintableStructure(Structure):
|
|||
<class_name object at 0x7fdf82fef9e0>
|
||||
this class will print
|
||||
class_name(field_name: formatted_value, field_name: formatted_value)
|
||||
|
||||
|
||||
_fmt_ dictionary of <str _field_ name> -> <str format>
|
||||
e.g. class that has _field_ 'hex_value', c_uint could be formatted with
|
||||
_fmt_ = {"hex_value" : "%08X"}
|
||||
|
|
@ -397,7 +397,7 @@ class _PrintableStructure(Structure):
|
|||
fmt = self._fmt_["<default>"]
|
||||
result.append(("%s: " + fmt) % (key, value))
|
||||
return self.__class__.__name__ + "(" + string.join(result, ", ") + ")"
|
||||
|
||||
|
||||
class c_nvmlUnitInfo_t(_PrintableStructure):
|
||||
_fields_ = [
|
||||
('name', c_char * 96),
|
||||
|
|
@ -444,7 +444,7 @@ class nvmlPciInfo_t(_PrintableStructure):
|
|||
('bus', c_uint),
|
||||
('device', c_uint),
|
||||
('pciDeviceId', c_uint),
|
||||
|
||||
|
||||
# Added in 2.285
|
||||
('pciSubSystemId', c_uint),
|
||||
('reserved0', c_uint),
|
||||
|
|
@ -503,7 +503,7 @@ class c_nvmlBridgeChipHierarchy_t(_PrintableStructure):
|
|||
_fields_ = [
|
||||
('bridgeCount', c_uint),
|
||||
('bridgeChipInfo', c_nvmlBridgeChipInfo_t * 128),
|
||||
]
|
||||
]
|
||||
|
||||
class c_nvmlEccErrorCounts_t(_PrintableStructure):
|
||||
_fields_ = [
|
||||
|
|
@ -582,7 +582,7 @@ nvmlClocksThrottleReasonAll = (
|
|||
nvmlClocksThrottleReasonSwPowerCap |
|
||||
nvmlClocksThrottleReasonHwSlowdown |
|
||||
nvmlClocksThrottleReasonUnknown
|
||||
)
|
||||
)
|
||||
|
||||
class c_nvmlEventData_t(_PrintableStructure):
|
||||
_fields_ = [
|
||||
|
|
@ -606,31 +606,31 @@ class c_nvmlAccountingStats_t(_PrintableStructure):
|
|||
## C function wrappers ##
|
||||
def nvmlInit():
|
||||
_LoadNvmlLibrary()
|
||||
|
||||
|
||||
#
|
||||
# Initialize the library
|
||||
#
|
||||
fn = _nvmlGetFunctionPointer("nvmlInit_v2")
|
||||
ret = fn()
|
||||
_nvmlCheckReturn(ret)
|
||||
|
||||
|
||||
# Atomically update refcount
|
||||
global _nvmlLib_refcount
|
||||
libLoadLock.acquire()
|
||||
_nvmlLib_refcount += 1
|
||||
libLoadLock.release()
|
||||
return None
|
||||
|
||||
|
||||
def _LoadNvmlLibrary():
|
||||
'''
|
||||
Load the library if it isn't loaded already
|
||||
'''
|
||||
global nvmlLib
|
||||
|
||||
|
||||
if (nvmlLib == None):
|
||||
# lock to ensure only one caller loads the library
|
||||
libLoadLock.acquire()
|
||||
|
||||
|
||||
try:
|
||||
# ensure the library still isn't loaded
|
||||
if (nvmlLib == None):
|
||||
|
|
@ -649,7 +649,7 @@ def _LoadNvmlLibrary():
|
|||
finally:
|
||||
# lock is always freed
|
||||
libLoadLock.release()
|
||||
|
||||
|
||||
def nvmlShutdown():
|
||||
#
|
||||
# Leave the library loaded, but shutdown the interface
|
||||
|
|
@ -657,7 +657,7 @@ def nvmlShutdown():
|
|||
fn = _nvmlGetFunctionPointer("nvmlShutdown")
|
||||
ret = fn()
|
||||
_nvmlCheckReturn(ret)
|
||||
|
||||
|
||||
# Atomically update refcount
|
||||
global _nvmlLib_refcount
|
||||
libLoadLock.acquire()
|
||||
|
|
@ -701,19 +701,19 @@ def nvmlSystemGetHicVersion():
|
|||
c_count = c_uint(0)
|
||||
hics = None
|
||||
fn = _nvmlGetFunctionPointer("nvmlSystemGetHicVersion")
|
||||
|
||||
|
||||
# get the count
|
||||
ret = fn(byref(c_count), None)
|
||||
|
||||
|
||||
# this should only fail with insufficient size
|
||||
if ((ret != NVML_SUCCESS) and
|
||||
(ret != NVML_ERROR_INSUFFICIENT_SIZE)):
|
||||
raise NVMLError(ret)
|
||||
|
||||
|
||||
# if there are no hics
|
||||
if (c_count.value == 0):
|
||||
return []
|
||||
|
||||
|
||||
hic_array = c_nvmlHwbcEntry_t * c_count.value
|
||||
hics = hic_array()
|
||||
ret = fn(byref(c_count), hics)
|
||||
|
|
@ -770,7 +770,7 @@ def nvmlUnitGetFanSpeedInfo(unit):
|
|||
ret = fn(unit, byref(c_speeds))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_speeds
|
||||
|
||||
|
||||
# added to API
|
||||
def nvmlUnitGetDeviceCount(unit):
|
||||
c_count = c_uint(0)
|
||||
|
|
@ -822,7 +822,7 @@ def nvmlDeviceGetHandleByUUID(uuid):
|
|||
ret = fn(c_uuid, byref(device))
|
||||
_nvmlCheckReturn(ret)
|
||||
return device
|
||||
|
||||
|
||||
def nvmlDeviceGetHandleByPciBusId(pciBusId):
|
||||
c_busId = c_char_p(pciBusId)
|
||||
device = c_nvmlDevice_t()
|
||||
|
|
@ -858,7 +858,7 @@ def nvmlDeviceGetBrand(handle):
|
|||
ret = fn(handle, byref(c_type))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_type.value
|
||||
|
||||
|
||||
def nvmlDeviceGetSerial(handle):
|
||||
c_serial = create_string_buffer(NVML_DEVICE_SERIAL_BUFFER_SIZE)
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetSerial")
|
||||
|
|
@ -892,14 +892,14 @@ def nvmlDeviceGetMinorNumber(handle):
|
|||
ret = fn(handle, byref(c_minor_number))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_minor_number.value
|
||||
|
||||
|
||||
def nvmlDeviceGetUUID(handle):
|
||||
c_uuid = create_string_buffer(NVML_DEVICE_UUID_BUFFER_SIZE)
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetUUID")
|
||||
ret = fn(handle, c_uuid, c_uint(NVML_DEVICE_UUID_BUFFER_SIZE))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_uuid.value
|
||||
|
||||
|
||||
def nvmlDeviceGetInforomVersion(handle, infoRomObject):
|
||||
c_version = create_string_buffer(NVML_DEVICE_INFOROM_VERSION_BUFFER_SIZE)
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetInforomVersion")
|
||||
|
|
@ -929,7 +929,7 @@ def nvmlDeviceValidateInforom(handle):
|
|||
fn = _nvmlGetFunctionPointer("nvmlDeviceValidateInforom")
|
||||
ret = fn(handle)
|
||||
_nvmlCheckReturn(ret)
|
||||
return None
|
||||
return None
|
||||
|
||||
def nvmlDeviceGetDisplayMode(handle):
|
||||
c_mode = _nvmlEnableState_t()
|
||||
|
|
@ -937,29 +937,29 @@ def nvmlDeviceGetDisplayMode(handle):
|
|||
ret = fn(handle, byref(c_mode))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_mode.value
|
||||
|
||||
|
||||
def nvmlDeviceGetDisplayActive(handle):
|
||||
c_mode = _nvmlEnableState_t()
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetDisplayActive")
|
||||
ret = fn(handle, byref(c_mode))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_mode.value
|
||||
|
||||
|
||||
|
||||
|
||||
def nvmlDeviceGetPersistenceMode(handle):
|
||||
c_state = _nvmlEnableState_t()
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetPersistenceMode")
|
||||
ret = fn(handle, byref(c_state))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_state.value
|
||||
|
||||
|
||||
def nvmlDeviceGetPciInfo(handle):
|
||||
c_info = nvmlPciInfo_t()
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetPciInfo_v2")
|
||||
ret = fn(handle, byref(c_info))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_info
|
||||
|
||||
|
||||
def nvmlDeviceGetClockInfo(handle, type):
|
||||
c_clock = c_uint()
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetClockInfo")
|
||||
|
|
@ -997,7 +997,7 @@ def nvmlDeviceGetSupportedMemoryClocks(handle):
|
|||
c_count = c_uint(0)
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetSupportedMemoryClocks")
|
||||
ret = fn(handle, byref(c_count), None)
|
||||
|
||||
|
||||
if (ret == NVML_SUCCESS):
|
||||
# special case, no clocks
|
||||
return []
|
||||
|
|
@ -1005,11 +1005,11 @@ def nvmlDeviceGetSupportedMemoryClocks(handle):
|
|||
# typical case
|
||||
clocks_array = c_uint * c_count.value
|
||||
c_clocks = clocks_array()
|
||||
|
||||
|
||||
# make the call again
|
||||
ret = fn(handle, byref(c_count), c_clocks)
|
||||
_nvmlCheckReturn(ret)
|
||||
|
||||
|
||||
procs = []
|
||||
for i in range(c_count.value):
|
||||
procs.append(c_clocks[i])
|
||||
|
|
@ -1025,7 +1025,7 @@ def nvmlDeviceGetSupportedGraphicsClocks(handle, memoryClockMHz):
|
|||
c_count = c_uint(0)
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetSupportedGraphicsClocks")
|
||||
ret = fn(handle, c_uint(memoryClockMHz), byref(c_count), None)
|
||||
|
||||
|
||||
if (ret == NVML_SUCCESS):
|
||||
# special case, no clocks
|
||||
return []
|
||||
|
|
@ -1033,11 +1033,11 @@ def nvmlDeviceGetSupportedGraphicsClocks(handle, memoryClockMHz):
|
|||
# typical case
|
||||
clocks_array = c_uint * c_count.value
|
||||
c_clocks = clocks_array()
|
||||
|
||||
|
||||
# make the call again
|
||||
ret = fn(handle, c_uint(memoryClockMHz), byref(c_count), c_clocks)
|
||||
_nvmlCheckReturn(ret)
|
||||
|
||||
|
||||
procs = []
|
||||
for i in range(c_count.value):
|
||||
procs.append(c_clocks[i])
|
||||
|
|
@ -1053,7 +1053,7 @@ def nvmlDeviceGetFanSpeed(handle):
|
|||
ret = fn(handle, byref(c_speed))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_speed.value
|
||||
|
||||
|
||||
def nvmlDeviceGetTemperature(handle, sensor):
|
||||
c_temp = c_uint()
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetTemperature")
|
||||
|
|
@ -1075,7 +1075,7 @@ def nvmlDeviceGetPowerState(handle):
|
|||
ret = fn(handle, byref(c_pstate))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_pstate.value
|
||||
|
||||
|
||||
def nvmlDeviceGetPerformanceState(handle):
|
||||
c_pstate = _nvmlPstates_t()
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetPerformanceState")
|
||||
|
|
@ -1089,7 +1089,7 @@ def nvmlDeviceGetPowerManagementMode(handle):
|
|||
ret = fn(handle, byref(c_pcapMode))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_pcapMode.value
|
||||
|
||||
|
||||
def nvmlDeviceGetPowerManagementLimit(handle):
|
||||
c_limit = c_uint()
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetPowerManagementLimit")
|
||||
|
|
@ -1113,7 +1113,7 @@ def nvmlDeviceGetPowerManagementDefaultLimit(handle):
|
|||
ret = fn(handle, byref(c_limit))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_limit.value
|
||||
|
||||
|
||||
|
||||
# Added in 331
|
||||
def nvmlDeviceGetEnforcedPowerLimit(handle):
|
||||
|
|
@ -1146,7 +1146,7 @@ def nvmlDeviceGetCurrentGpuOperationMode(handle):
|
|||
# Added in 4.304
|
||||
def nvmlDeviceGetPendingGpuOperationMode(handle):
|
||||
return nvmlDeviceGetGpuOperationMode(handle)[1]
|
||||
|
||||
|
||||
def nvmlDeviceGetMemoryInfo(handle):
|
||||
c_memory = c_nvmlMemory_t()
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetMemoryInfo")
|
||||
|
|
@ -1160,14 +1160,14 @@ def nvmlDeviceGetBAR1MemoryInfo(handle):
|
|||
ret = fn(handle, byref(c_bar1_memory))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_bar1_memory
|
||||
|
||||
|
||||
def nvmlDeviceGetComputeMode(handle):
|
||||
c_mode = _nvmlComputeMode_t()
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetComputeMode")
|
||||
ret = fn(handle, byref(c_mode))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_mode.value
|
||||
|
||||
|
||||
def nvmlDeviceGetEccMode(handle):
|
||||
c_currState = _nvmlEnableState_t()
|
||||
c_pendingState = _nvmlEnableState_t()
|
||||
|
|
@ -1200,7 +1200,7 @@ def nvmlDeviceGetDetailedEccErrors(handle, errorType, counterType):
|
|||
_nvmlEccCounterType_t(counterType), byref(c_counts))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_counts
|
||||
|
||||
|
||||
# Added in 4.304
|
||||
def nvmlDeviceGetMemoryErrorCounter(handle, errorType, counterType, locationType):
|
||||
c_count = c_ulonglong()
|
||||
|
|
@ -1212,7 +1212,7 @@ def nvmlDeviceGetMemoryErrorCounter(handle, errorType, counterType, locationType
|
|||
byref(c_count))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_count.value
|
||||
|
||||
|
||||
def nvmlDeviceGetUtilizationRates(handle):
|
||||
c_util = c_nvmlUtilization_t()
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetUtilizationRates")
|
||||
|
|
@ -1273,7 +1273,7 @@ def nvmlDeviceGetComputeRunningProcesses(handle):
|
|||
c_count = c_uint(0)
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetComputeRunningProcesses")
|
||||
ret = fn(handle, byref(c_count), None)
|
||||
|
||||
|
||||
if (ret == NVML_SUCCESS):
|
||||
# special case, no running processes
|
||||
return []
|
||||
|
|
@ -1283,11 +1283,11 @@ def nvmlDeviceGetComputeRunningProcesses(handle):
|
|||
c_count.value = c_count.value * 2 + 5
|
||||
proc_array = c_nvmlProcessInfo_t * c_count.value
|
||||
c_procs = proc_array()
|
||||
|
||||
|
||||
# make the call again
|
||||
ret = fn(handle, byref(c_count), c_procs)
|
||||
_nvmlCheckReturn(ret)
|
||||
|
||||
|
||||
procs = []
|
||||
for i in range(c_count.value):
|
||||
# use an alternative struct for this object
|
||||
|
|
@ -1317,11 +1317,11 @@ def nvmlDeviceGetGraphicsRunningProcesses(handle):
|
|||
c_count.value = c_count.value * 2 + 5
|
||||
proc_array = c_nvmlProcessInfo_t * c_count.value
|
||||
c_procs = proc_array()
|
||||
|
||||
|
||||
# make the call again
|
||||
ret = fn(handle, byref(c_count), c_procs)
|
||||
_nvmlCheckReturn(ret)
|
||||
|
||||
|
||||
procs = []
|
||||
for i in range(c_count.value):
|
||||
# use an alternative struct for this object
|
||||
|
|
@ -1351,19 +1351,19 @@ def nvmlUnitSetLedState(unit, color):
|
|||
ret = fn(unit, _nvmlLedColor_t(color))
|
||||
_nvmlCheckReturn(ret)
|
||||
return None
|
||||
|
||||
|
||||
def nvmlDeviceSetPersistenceMode(handle, mode):
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceSetPersistenceMode")
|
||||
ret = fn(handle, _nvmlEnableState_t(mode))
|
||||
_nvmlCheckReturn(ret)
|
||||
return None
|
||||
|
||||
|
||||
def nvmlDeviceSetComputeMode(handle, mode):
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceSetComputeMode")
|
||||
ret = fn(handle, _nvmlComputeMode_t(mode))
|
||||
_nvmlCheckReturn(ret)
|
||||
return None
|
||||
|
||||
|
||||
def nvmlDeviceSetEccMode(handle, mode):
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceSetEccMode")
|
||||
ret = fn(handle, _nvmlEnableState_t(mode))
|
||||
|
|
@ -1381,15 +1381,15 @@ def nvmlDeviceSetDriverModel(handle, model):
|
|||
ret = fn(handle, _nvmlDriverModel_t(model))
|
||||
_nvmlCheckReturn(ret)
|
||||
return None
|
||||
|
||||
def nvmlDeviceSetAutoBoostedClocksEnabled(handle, enabled):
|
||||
|
||||
def nvmlDeviceSetAutoBoostedClocksEnabled(handle, enabled):
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceSetAutoBoostedClocksEnabled")
|
||||
ret = fn(handle, _nvmlEnableState_t(enabled))
|
||||
_nvmlCheckReturn(ret)
|
||||
return None
|
||||
#Throws NVML_ERROR_NOT_SUPPORTED if hardware doesn't support setting auto boosted clocks
|
||||
|
||||
def nvmlDeviceSetDefaultAutoBoostedClocksEnabled(handle, enabled, flags):
|
||||
def nvmlDeviceSetDefaultAutoBoostedClocksEnabled(handle, enabled, flags):
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceSetDefaultAutoBoostedClocksEnabled")
|
||||
ret = fn(handle, _nvmlEnableState_t(enabled), c_uint(flags))
|
||||
_nvmlCheckReturn(ret)
|
||||
|
|
@ -1402,7 +1402,7 @@ def nvmlDeviceSetApplicationsClocks(handle, maxMemClockMHz, maxGraphicsClockMHz)
|
|||
ret = fn(handle, c_uint(maxMemClockMHz), c_uint(maxGraphicsClockMHz))
|
||||
_nvmlCheckReturn(ret)
|
||||
return None
|
||||
|
||||
|
||||
# Added in 4.304
|
||||
def nvmlDeviceResetApplicationsClocks(handle):
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceResetApplicationsClocks")
|
||||
|
|
@ -1416,7 +1416,7 @@ def nvmlDeviceSetPowerManagementLimit(handle, limit):
|
|||
ret = fn(handle, c_uint(limit))
|
||||
_nvmlCheckReturn(ret)
|
||||
return None
|
||||
|
||||
|
||||
# Added in 4.304
|
||||
def nvmlDeviceSetGpuOperationMode(handle, mode):
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceSetGpuOperationMode")
|
||||
|
|
@ -1534,7 +1534,7 @@ def nvmlDeviceGetAccountingMode(handle):
|
|||
ret = fn(handle, byref(c_mode))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_mode.value
|
||||
|
||||
|
||||
def nvmlDeviceSetAccountingMode(handle, mode):
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceSetAccountingMode")
|
||||
ret = fn(handle, _nvmlEnableState_t(mode))
|
||||
|
|
@ -1563,7 +1563,7 @@ def nvmlDeviceGetAccountingPids(handle):
|
|||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetAccountingPids")
|
||||
ret = fn(handle, byref(count), pids)
|
||||
_nvmlCheckReturn(ret)
|
||||
return map(int, pids[0:count.value])
|
||||
return map(int, pids[0:count.value])
|
||||
|
||||
def nvmlDeviceGetAccountingBufferSize(handle):
|
||||
bufferSize = c_uint()
|
||||
|
|
@ -1576,10 +1576,10 @@ def nvmlDeviceGetRetiredPages(device, sourceFilter):
|
|||
c_source = _nvmlPageRetirementCause_t(sourceFilter)
|
||||
c_count = c_uint(0)
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetRetiredPages")
|
||||
|
||||
|
||||
# First call will get the size
|
||||
ret = fn(device, c_source, byref(c_count), None)
|
||||
|
||||
|
||||
# this should only fail with insufficient size
|
||||
if ((ret != NVML_SUCCESS) and
|
||||
(ret != NVML_ERROR_INSUFFICIENT_SIZE)):
|
||||
|
|
@ -1651,7 +1651,7 @@ def nvmlDeviceGetViolationStatus(device, perfPolicyType):
|
|||
ret = fn(device, c_perfPolicy_type, byref(c_violTime))
|
||||
_nvmlCheckReturn(ret)
|
||||
return c_violTime
|
||||
|
||||
|
||||
def nvmlDeviceGetPcieThroughput(device, counter):
|
||||
c_util = c_uint()
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetPcieThroughput")
|
||||
|
|
@ -1704,17 +1704,17 @@ def nvmlDeviceGetTopologyCommonAncestor(device1, device2):
|
|||
def nvmlDeviceGetCudaComputeCapability(device):
|
||||
c_major = c_int()
|
||||
c_minor = c_int()
|
||||
|
||||
|
||||
try:
|
||||
fn = _nvmlGetFunctionPointer("nvmlDeviceGetCudaComputeCapability")
|
||||
except:
|
||||
return 9, 9
|
||||
|
||||
|
||||
# get the count
|
||||
ret = fn(device, byref(c_major), byref(c_minor))
|
||||
|
||||
|
||||
# this should only fail with insufficient size
|
||||
if (ret != NVML_SUCCESS):
|
||||
raise NVMLError(ret)
|
||||
|
||||
return c_major.value, c_minor.value
|
||||
return c_major.value, c_minor.value
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue