Main Content

Esta página es para la versión anterior. La página correspondiente en inglés ha sido eliminada en la versión actual.

Acelerar la correlación con las GPU

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 mediante una GPU. Este ejemplo requiere una licencia de usuario ™ Parallel Computing Toolbox. Consulte para ver qué GPU son compatibles.GPU Support by Release (Parallel Computing Toolbox)

Introducción

Comience por aprender información básica sobre la GPU en su máquina. Para acceder a la GPU, utilice Parallel Computing Toolbox.

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 utilizar una sola función para comparar tanto la CPU como la GPU. Sin embargo, dado que el código de la GPU se ejecuta de forma asincrónica desde la CPU, se debe tomar una precaución especial al medir el rendimiento. Antes de medir el tiempo necesario para ejecutar una función, asegúrese de que todo el procesamiento de GPU ha terminado 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 comparan tres tipos diferentes de correlación cruzada.

Benchmark Simple Cross-Correlation

En el primer caso, dos vectores de igual tamaño se correlacionan entre sí mediante 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 respecto al 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 

Correlación cruzada de columnas de matriz de evaluación comparativa

En el segundo caso, las columnas de una matriz A están correlacionadas entre sí 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 respecto al 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 Multi-Correlación Bidimensional

Para el caso final, dos matrices, X e Y, se correlacionan entre sí mediante xcorr2(X,Y). X es de tamaño fijo mientras que Y puede variar. La aceleración se traza contra 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 las funciones de procesamiento de señal acelerada por GPU en la tabla de contenido de Signal Processing Toolbox (TM).ver la sección "Aceleración de GPU"