query or select a gpu device -凯发k8网页登录
query or select a gpu device
description
a gpudevice object represents a graphic processing unit (gpu)
in your computer. you can use the gpu to run matlab® code that supports gpuarray variables or execute cuda kernels using
objects.
you can use a gpudevice object to inspect the properties of your gpu
device, reset the gpu device, or wait for your gpu to finish executing a computation. to
obtain a gpudevice object, use the gpudevice function.
you can also select or deselect your gpu device using the gpudevice
function. if you have access to multiple gpus, use the gpudevice function
to choose a specific gpu device on which to execute your code.
you do not need to use a gpudevice object to run functions on a gpu.
for more information on how to use gpu-enabled functions, see run matlab functions on a gpu.
creation
description
gpudevice displays the properties of the currently selected gpu
device. if there is no currently selected device, gpudevice selects the
default device without clearing it. use this syntax when you want to inspect the
properties of your gpu device.
d = gpudevice returns a gpudevice object
representing the currently selected device. if there is no currently selected device,
gpudevice selects the default device and returns a
gpudevice object representing that device without clearing it.
d = gpudevice( selects the gpu device
specified by index indx)indx. if the specified gpu device is not
supported, an error occurs. this syntax resets the specified device and clears its memory,
even if the device is already currently selected (equivalent to the function). all workspace variables representing
gpuarray or cudakernel variables are now invalid
and must be cleared from the workspace or redefined.
gpudevice([]), with an empty argument (as opposed to no
argument), deselects the gpu device and clears its memory of gpuarray
and cudakernel variables. this syntax leaves no gpu device selected as
the current device.
input arguments
properties
object functions
you can identify, select, reset, or wait for a gpu device using the following functions:
| number of gpu devices present | |
| reset gpu device and clear its memory | |
| wait for gpu calculation to complete |
the following functions are also available:
parallel.gpu.gpudevice.isavailable(indx) | returns logical 1 or true if the gpu
specified by index indx is supported and capable of being
selected. indx can be an integer or a vector of integers; the
default index is the current device. |
parallel.gpu.gpudevice.getdevice(indx) | returns a gpudevice object without selecting it. |
for a complete list of functions, use the methods function on the
gpudevice object:
methods('parallel.gpu.gpudevice')you can get help on any of the object functions with the following command:
help parallel.gpu.gpudevice.functionname
where functionname is the name of the function. for example, to
get help on isavailable, type:
help parallel.gpu.gpudevice.isavailable
examples
identify and select a gpu device
this example shows how to use gpudevice to identify and select which device you want to use.
to determine how many gpu devices are available in your computer, use the function.
gpudevicecount("available")ans = 2
when there are multiple devices, the first is the default. you can examine its properties with the function to determine if that is the one you want to use.
gpudevicetable
ans=2×5 table
index name computecapability deviceavailable deviceselected
_____ __________________ _________________ _______________ ______________
1 "nvidia rtx a5000" "8.6" true false
2 "quadro p620" "6.1" true true
if the first device is the device you want to use, you can proceed. to run computations on the gpu, use gpuarray enabled functions. for more information, see run matlab functions on a gpu.
to use another device, call gpudevice with the index of the other device.
gpudevice(2)
ans =
cudadevice with properties:
name: 'quadro p620'
index: 2
computecapability: '6.1'
supportsdouble: 1
graphicsdriverversion: '511.79'
drivermodel: 'wddm'
toolkitversion: 11.2000
maxthreadsperblock: 1024
maxshmemperblock: 49152 (49.15 kb)
maxthreadblocksize: [1024 1024 64]
maxgridsize: [2.1475e 09 65535 65535]
simdwidth: 32
totalmemory: 2147287040 (2.15 gb)
availablememory: 1615209678 (1.62 gb)
cachepolicy: 'balanced'
multiprocessorcount: 4
clockratekhz: 0
computemode: 'default'
gpuoverlapstransfers: 1
kernelexecutiontimeout: 1
canmaphostmemory: 1
devicesupported: 1
deviceavailable: 1
deviceselected: 1
alternatively, you can determine how many gpu devices are available, inspect some of their properties, and select a device to use from the matlab® desktop. on the home tab, in the environment area, select parallel > select gpu environment.
query compute capabilities
create an object representing the default gpu device and query its compute capability.
d = gpudevice; d.computecapability
ans = '8.6'
query the compute capabilities of all available gpu devices.
for idx = 1:gpudevicecount d = gpudevice(idx); fprintf(1,"device %i has computecapability %s \n", ... d.index,d.computecapability) end
device 1 has computecapability 8.6 device 2 has computecapability 6.1
compare the compute capabilities and availability of the gpu devices in your system using .
gpudevicetable
ans=2×5 table
index name computecapability deviceavailable deviceselected
_____ __________________ _________________ _______________ ______________
1 "nvidia rtx a5000" "8.6" true false
2 "quadro p620" "6.1" true true
query and change caching policy
change the caching policy of your gpu.
create an object representing the default gpu device.
d = gpudevice
d =
cudadevice with properties:
name: 'nvidia rtx a5000'
index: 1
computecapability: '8.6'
supportsdouble: 1
graphicsdriverversion: '511.79'
drivermodel: 'tcc'
toolkitversion: 11.2000
maxthreadsperblock: 1024
maxshmemperblock: 49152 (49.15 kb)
maxthreadblocksize: [1024 1024 64]
maxgridsize: [2.1475e 09 65535 65535]
simdwidth: 32
totalmemory: 25553076224 (25.55 gb)
availablememory: 25145376768 (25.15 gb)
cachepolicy: 'balanced'
multiprocessorcount: 64
clockratekhz: 0
computemode: 'default'
gpuoverlapstransfers: 1
kernelexecutiontimeout: 0
canmaphostmemory: 1
devicesupported: 1
deviceavailable: 1
deviceselected: 1
access the cachepolicy property of the gpu device.
d.cachepolicy
ans = 'balanced'
change the caching policy to allow the gpu to cache the maximum amount of memory for accelerating computation.
d.cachepolicy = "maximum";
d.cachepolicyans = 'maximum'
reset the caching policy to the default policy by setting the property to [].
d.cachepolicy = [];
calling reset(d) or selecting another device with gpudevice also resets the caching policy to its default value.
use multiple gpus in parallel pool
if you have access to several gpus, you can perform your calculations on multiple gpus in parallel using a parallel pool.
to determine the number of gpus that are available for use in matlab, use the function.
availablegpus = gpudevicecount("available")availablegpus = 3
start a parallel pool with as many workers as available gpus. for best performance, matlab assigns a different gpu to each worker by default.
parpool('processes',availablegpus);starting parallel pool (parpool) using the 'processes' profile ... connected to the parallel pool (number of workers: 3).
to identify which gpu each worker is using, call gpudevice inside an spmd block. the spmd block runs gpudevice on every worker.
spmd gpudevice end
use parallel language features, such as parfor or , to distribute your computations to workers in the parallel pool. if you use gpuarray enabled functions in your computations, these functions run on the gpu of the worker. for more information, see run matlab functions on a gpu. for an example, see run matlab functions on multiple gpus.
when you are done with your computations, shut down the parallel pool. you can use the function to obtain the current parallel pool.
delete(gcp('nocreate'));if you want to use a different choice of gpus, then you can use gpudevice to select a particular gpu on each worker, using the gpu device index. you can obtain the index of each gpu device in your system using the gpudevicecount function.
suppose you have three gpus available in your system, but you want to use only two for a computation. obtain the indices of the devices.
[availablegpus,gpuindx] = gpudevicecount("available")availablegpus = 3
gpuindx = 1×3
1 2 3
define the indices of the devices you want to use.
usegpus = [1 3];
start your parallel pool. use an spmd block and gpudevice to associate each worker with one of the gpus you want to use, using the device index. the spmdindex function identifies the index of each worker.
parpool('processes',numel(usegpus));starting parallel pool (parpool) using the 'processes' profile ... connected to the parallel pool (number of workers: 2).
spmd gpudevice(usegpus(spmdindex)); end
as a best practice, and for best performance, assign a different gpu to each worker.
when you are done with your computations, shut down the parallel pool.
delete(gcp('nocreate'));version history
introduced in r2010b
select a web site
choose a web site to get translated content where available and see local events and offers. based on your location, we recommend that you select: .
you can also select a web site from the following list:
americas
- (español)
- (english)
- (english)
europe
- (english)
- (english)
- (deutsch)
- (español)
- (english)
- (français)
- (english)
- (italiano)
- (english)
- (english)
- (english)
- (deutsch)
- (english)
- (english)
- switzerland
- (english)
asia pacific
- (english)
- (english)
- (english)
- 中国
- (日本語)
- (한국어)