array stored on gpu -凯发k8网页登录

to transfer data from the cpu to the gpu, use the gpuarray function.

create an array x.

x = [1,2,3];

transfer x to the gpu.

g = gpuarray(x);

check that the data is on the gpu.

isgpuarray(g)

ans = logical
   1

calculate the element-wise square of the array g.

gsq = g.^2;

transfer the result gsq back to the cpu.

xsq = gather(gsq)

xsq = 1×3
     1     4     9

check that the data is not on the gpu.

isgpuarray(xsq)

ans = logical
   0

you can create data directly on the gpu directly by using some matlab functions and specifying the option "gpuarray".

create an array of random numbers directly on the gpu.

g = rand(1,3,"gpuarray")

g =
    0.3640    0.5421    0.6543

check that the output is stored on the gpu.

isgpuarray(g)

ans = logical
   1

this example shows how to use gpuarray-enabled matlab functions to operate with gpuarray objects. you can check the properties of your gpu using the gpudevice function.

gpudevice

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: 1354000
               computemode: 'default'
      gpuoverlapstransfers: 1
    kernelexecutiontimeout: 1
          canmaphostmemory: 1
           devicesupported: 1
           deviceavailable: 1
            deviceselected: 1

create a row vector that repeats values from -15 to 15. to transfer it to the gpu and create a gpuarray object, use the gpuarray function.

x = [-15:15 0 -15:15 0 -15:15];
gpux = gpuarray(x);
whos gpux

  name      size            bytes  class       attributes
  gpux      1x95              760  gpuarray              

to operate with gpuarray objects, use any gpuarray-enabled matlab function. matlab automatically runs calculations on the gpu. for more information, see run matlab functions on a gpu. for example, use diag, expm, mod, round, abs, and fliplr together.

gpue = expm(diag(gpux,-1)) * expm(diag(gpux,1));
gpum = mod(round(abs(gpue)),2);
gpuf = gpum   fliplr(gpum);

plot the results.

imagesc(gpuf);
colormap(flip(gray));

if you need to transfer the data back from the gpu, use gather. transferring data back to the cpu can be costly, and is generally not necessary unless you need to use your result with functions that do not support gpuarray.

result = gather(gpuf);
whos result

  name         size            bytes  class     attributes
  result      96x96            73728  double              

in general, running code on the cpu and the gpu can produce different results due to numerical precision and algorithmic differences between the gpu and cpu. answers from the cpu and gpu are both equally valid floating point approximations to the true analytical result, having been subjected to different roundoff behavior during computation. in this example, the results are integers and round eliminates the roundoff errors.

this example shows how to use matlab functions and operators with gpuarray objects to compute the integral of a function by using the monte carlo integration method.

define the number of points to sample. sample points in the domain of the function, the interval [-1,1] in both x and y coordinates, by creating random points with the rand function. to create a random array directly on the gpu, use the rand function and specify "gpuarray". for more information, see .

n = 1e6;
x = 2*rand(n,1,"gpuarray")-1;
y = 2*rand(n,1,"gpuarray")-1;

define the function to integrate, and use the monte carlo integration formula on it. this function approximates the value of π by sampling points within the unit circle. because the code uses gpuarray-enabled functions and operators on gpuarray objects, the computations automatically run on the gpu. you can perform binary operations such as element-wise multiplication using the same syntax that you use for matlab arrays. for more information about gpuarray-enabled functions, see run matlab functions on a gpu.

f = x.^2   y.^2 <= 1;
result = 4*1/n*f*ones(n,1,"gpuarray")

result =
    3.1403