Esta página aún no se ha traducido para esta versión. Puede ver la versión más reciente de esta página en inglés.

Acelerando la correlación con GPUs

En este ejemplo se muestra cómo se puede utilizar una GPU para acelerar la correlación cruzada. Muchos problemas de correlación implican grandes conjuntos de datos y se pueden resolver mucho más rápido usando una GPU. Este ejemplo requiere una licencia de usuario de Parallel Computing Toolbox™. Consulte para ver qué GPU son compatibles.GPU Support by Release (Parallel Computing Toolbox)

Introducción

Empiece por aprender información básica sobre la GPU en su máquina. Para acceder a la GPU, utilice la caja de herramientas de computación paralela.

fprintf('Benchmarking GPU-accelerated Cross-Correlation.\n');  if ~(parallel.gpu.GPUDevice.isAvailable)     fprintf(['\n\t**GPU not available. Stopping.**\n']);     return; else     dev = gpuDevice;     fprintf(...     'GPU detected (%s, %d multiprocessors, Compute Capability %s)',...     dev.Name, dev.MultiprocessorCount, dev.ComputeCapability); end 
Benchmarking GPU-accelerated Cross-Correlation. GPU detected (TITAN Xp, 30 multiprocessors, Compute Capability 6.1)

Funciones de benchmarking

Dado que el código escrito para la CPU se puede portar para ejecutarse en la GPU, se puede usar una sola función para comparar la CPU y la GPU. Sin embargo, dado que el código de la GPU se ejecuta asincrónicamente desde la CPU, se debe tomar precauciones especiales al medir el rendimiento. Antes de medir el tiempo que se ha tardado en ejecutar una función, asegúrese de que todo el procesamiento de la GPU haya finalizado ejecutando el método ' Wait ' en el dispositivo. Esta llamada adicional no tendrá ningún efecto en el rendimiento de la CPU.

En este ejemplo se benchmarks tres tipos diferentes de correlación cruzada.

La correlación cruzada simple de Benchmark

En el primer caso, dos vectores de igual tamaño se correlacionan con la sintaxis.xcorr(u,v) La relación entre el tiempo de ejecución de la CPU y el tiempo de ejecución de la GPU se traza con el tamaño de los vectores.

fprintf('\n\n *** Benchmarking vector-vector cross-correlation*** \n\n'); fprintf('Benchmarking function :\n'); type('benchXcorrVec'); fprintf('\n\n');  sizes = [2000 1e4 1e5 5e5 1e6]; tc = zeros(1,numel(sizes)); tg = zeros(1,numel(sizes)); numruns = 10;  for s=1:numel(sizes);     fprintf('Running xcorr of %d elements...\n', sizes(s));     delchar = repmat('\b', 1,numruns);      a = rand(sizes(s),1);     b = rand(sizes(s),1);     tc(s) = benchXcorrVec(a, b, numruns);     fprintf([delchar '\t\tCPU  time : %.2f ms\n'], 1000*tc(s));     tg(s) = benchXcorrVec(gpuArray(a), gpuArray(b), numruns);     fprintf([delchar '\t\tGPU time :  %.2f ms\n'], 1000*tg(s)); end  %Plot the results fig = figure; ax = axes('parent', fig); semilogx(ax, sizes, tc./tg, 'r*-'); ylabel(ax, 'Speedup'); xlabel(ax, 'Vector size'); title(ax, 'GPU Acceleration of XCORR'); drawnow; 
   *** Benchmarking vector-vector cross-correlation***   Benchmarking function :  function t = benchXcorrVec(u,v, numruns) %Used to benchmark xcorr with vector inputs on the CPU and GPU.      %   Copyright 2012 The MathWorks, Inc.      timevec = zeros(1,numruns);     gdev = gpuDevice;     for ii=1:numruns         ts = tic;         o = xcorr(u,v); %#ok<NASGU>         wait(gdev)         timevec(ii) = toc(ts);         fprintf('.');     end     t = min(timevec); end   Running xcorr of 2000 elements...   CPU  time : 0.21 ms   GPU time :  4.26 ms Running xcorr of 10000 elements...   CPU  time : 1.03 ms   GPU time :  4.37 ms Running xcorr of 100000 elements...   CPU  time : 14.04 ms   GPU time :  6.28 ms Running xcorr of 500000 elements...   CPU  time : 55.98 ms   GPU time :  16.09 ms Running xcorr of 1000000 elements...   CPU  time : 169.00 ms   GPU time :  25.60 ms 

Benchmarking correlación de columna de matriz

Para el segundo caso, las columnas de una matriz a se correlacionan por pares para producir una salida de matriz grande de todas las correlaciones utilizando la sintaxis xcorr (A). La relación entre el tiempo de ejecución de la CPU y el tiempo de ejecución de la GPU se traza con el tamaño de la matriz A.

fprintf('\n\n *** Benchmarking matrix column cross-correlation*** \n\n'); fprintf('Benchmarking function :\n'); type('benchXcorrMatrix'); fprintf('\n\n');  sizes = floor(linspace(0,100, 11)); sizes(1) = []; tc = zeros(1,numel(sizes)); tg = zeros(1,numel(sizes)); numruns = 10;  for s=1:numel(sizes);     fprintf('Running xcorr (matrix) of a %d x %d matrix...\n', sizes(s), sizes(s));     delchar = repmat('\b', 1,numruns);      a = rand(sizes(s));     tc(s) = benchXcorrMatrix(a, numruns);     fprintf([delchar '\t\tCPU  time : %.2f ms\n'], 1000*tc(s));     tg(s) = benchXcorrMatrix(gpuArray(a), numruns);     fprintf([delchar '\t\tGPU time :  %.2f ms\n'], 1000*tg(s)); end  %Plot the results fig = figure; ax = axes('parent', fig); plot(ax, sizes.^2, tc./tg, 'r*-'); ylabel(ax, 'Speedup'); xlabel(ax, 'Matrix Elements'); title(ax, 'GPU Acceleration of XCORR (Matrix)'); drawnow; 
   *** Benchmarking matrix column cross-correlation***   Benchmarking function :  function t = benchXcorrMatrix(A, numruns) %Used to benchmark xcorr with Matrix input on CPU and GPU.      %   Copyright 2012 The MathWorks, Inc.      timevec = zeros(1,numruns);     gdev = gpuDevice;     for ii=1:numruns,         ts = tic;         o = xcorr(A); %#ok<NASGU>         wait(gdev)         timevec(ii) = toc(ts);         fprintf('.');     end     t = min(timevec); end   Running xcorr (matrix) of a 10 x 10 matrix...   CPU  time : 0.18 ms   GPU time :  5.00 ms Running xcorr (matrix) of a 20 x 20 matrix...   CPU  time : 0.48 ms   GPU time :  4.83 ms Running xcorr (matrix) of a 30 x 30 matrix...   CPU  time : 0.85 ms   GPU time :  4.84 ms Running xcorr (matrix) of a 40 x 40 matrix...   CPU  time : 3.38 ms   GPU time :  5.57 ms Running xcorr (matrix) of a 50 x 50 matrix...   CPU  time : 5.60 ms   GPU time :  5.22 ms Running xcorr (matrix) of a 60 x 60 matrix...   CPU  time : 8.49 ms   GPU time :  5.39 ms Running xcorr (matrix) of a 70 x 70 matrix...   CPU  time : 20.43 ms   GPU time :  5.92 ms Running xcorr (matrix) of a 80 x 80 matrix...   CPU  time : 26.79 ms   GPU time :  6.24 ms Running xcorr (matrix) of a 90 x 90 matrix...   CPU  time : 40.04 ms   GPU time :  6.89 ms Running xcorr (matrix) of a 100 x 100 matrix...   CPU  time : 49.69 ms   GPU time :  7.32 ms 

Benchmarking de correlación cruzada bidimensional

Para el caso final, dos matrices, X e y, se correlacionan de cruz usando xcorr2 (X, Y). X se fija en tamaño mientras Y se permite variar. El SpeedUp se traza con el tamaño de la segunda matriz.

fprintf('\n\n *** Benchmarking 2-D cross-correlation*** \n\n'); fprintf('Benchmarking function :\n'); type('benchXcorr2'); fprintf('\n\n');  sizes = [100, 200, 500, 1000, 1500, 2000]; tc = zeros(1,numel(sizes)); tg = zeros(1,numel(sizes)); numruns = 4; a = rand(100);  for s=1:numel(sizes);     fprintf('Running xcorr2 of a 100x100 matrix and %d x %d matrix...\n', sizes(s), sizes(s));     delchar = repmat('\b', 1,numruns);      b = rand(sizes(s));     tc(s) = benchXcorr2(a, b, numruns);     fprintf([delchar '\t\tCPU  time : %.2f ms\n'], 1000*tc(s));     tg(s) = benchXcorr2(gpuArray(a), gpuArray(b), numruns);     fprintf([delchar '\t\tGPU time :  %.2f ms\n'], 1000*tg(s)); end  %Plot the results fig = figure; ax =axes('parent', fig); semilogx(ax, sizes.^2, tc./tg, 'r*-'); ylabel(ax, 'Speedup'); xlabel(ax, 'Matrix Elements'); title(ax, 'GPU Acceleration of XCORR2'); drawnow;  fprintf('\n\nBenchmarking completed.\n\n'); 
   *** Benchmarking 2-D cross-correlation***   Benchmarking function :  function t = benchXcorr2(X, Y, numruns) %Used to benchmark xcorr2 on the CPU and GPU.  %   Copyright 2012 The MathWorks, Inc.       timevec = zeros(1,numruns);     gdev = gpuDevice;     for ii=1:numruns,         ts = tic;         o = xcorr2(X,Y); %#ok<NASGU>         wait(gdev)         timevec(ii) = toc(ts);         fprintf('.');     end     t = min(timevec); end   Running xcorr2 of a 100x100 matrix and 100 x 100 matrix...   CPU  time : 20.35 ms   GPU time :  6.96 ms Running xcorr2 of a 100x100 matrix and 200 x 200 matrix...   CPU  time : 42.87 ms   GPU time :  11.72 ms Running xcorr2 of a 100x100 matrix and 500 x 500 matrix...   CPU  time : 125.23 ms   GPU time :  39.67 ms Running xcorr2 of a 100x100 matrix and 1000 x 1000 matrix...   CPU  time : 386.59 ms   GPU time :  88.46 ms Running xcorr2 of a 100x100 matrix and 1500 x 1500 matrix...   CPU  time : 788.38 ms   GPU time :  165.04 ms Running xcorr2 of a 100x100 matrix and 2000 x 2000 matrix...   CPU  time : 1523.05 ms   GPU time :  279.55 ms   Benchmarking completed.  

Otras funciones de procesamiento de señal acelerada por GPU

Hay varias otras funciones de procesamiento de señal que se pueden ejecutar en la GPU. Estas funciones incluyen FFT, iFFT, conv, Filter, fftfilt y más. En algunos casos, puede lograr una aceleración grande en relación con la CPU. Para obtener una lista completa de funciones de procesamiento de señales aceleradas por GPU en la tabla de contenido de Signal Processing Toolbox (TM).Consulte la sección "aceleración de GPU"