Gostaria de agradecer a Stephen pela resposta muito rápida em um post anterior. Esta é uma pergunta de acompanhamento para este postPor que o Renderscript muito simples é executado 3 vezes mais lentamente na GPU do que na CPU

Minha plataforma dev é a seguinte

Development OS: Windows 7 32-bit
Phone: Nexus 5
Phone OS version: Android 4.4
SDK bundle: adt-bundle-windows-x86-20131030
Build-tool version: 19
SDK tool version: 22.3
Platform tool version: 19

A fim de avaliar o desempenho da computação GPU Renderscript e compreender o truque geral de fazer código mais rápido pelo Renderscript, fiz o seguinte teste.

Eu verifiquei o código do projeto de código aberto android do Google, usando o tag android-4.2.2_r1.2. Eu usei essa tag simplesmente porque a amostra de teste ImageProcessing não está disponível na versão mais recente.

Então usei o projeto em "base \ tests \ RenderScriptTests \ ImageProcessing" no teste. Eu gravei o desempenho do código em execução na GPU, bem como a CPU e o desempenho está listado abaixo.

                         GPU    CPU
Levels Vec3 Relaxed     7.45ms  14.89ms
Levels Vec4 Relaxed     6.04ms  12.85ms
Levels Vec3 Full        N/A     28.97ms
Levels Vec4 Full        N/A     35.65ml
Blur radius 25          203.2ms 245.60ms
Greyscale               7.16ms  11.54ms
Grain                   33.33ms 21.73ms
Fisheye Full            N/A     51.55ms
Fisheye Relaxed         92.90ms 45.34ms
Fisheye Approx Full     N/A     51.65ms
Fisheye Approx Relaxed  93.09ms 39.11ms
Vignette Full           N/A     44.17ms
Vignette Relaxed        8.02ms  46.68ms
Vignette Approx Full    N/A     45.04ms
Vignette Approx Relaxed 8.20ms  43.69ms
Convolve 3x3            37.66ms 16.81ms
Convolve 3x3 Intrinsics N/A     4.57ms
ColorMatrix             5.87ms  8.26ms
ColorMatrix Intrinsics  N/A     2.70ms
ColorMatrix Intinsics Grey  N/A 2.52ms
Copy                    5.59ms  2.40ms
CrossProcess(using LUT) N/A     5.74ms
Convolve 5x5            84.25ms 46.59ms
Convolve 5x5 Intrinsics N/A     9.69ms
Mandelbrot              N/A     50.2ms
Blend Intrinsics        N/A     21.80ms

O N / A na tabela é causado pela precisão total ou pelo fato de os intrínsecos rs não rodarem na GPU. Podemos ver que entre 13 algoritmos executados na GPU, 6 deles são mais lentos na GPU. Como esse código foi escrito pelo Google, considero que esse fenômeno vale a pena ser investigado. Pelo menos, "eu suponho que o código vai correr mais rápido na GPU", vi deRenderscript e a GPU não segura aqui.

Eu investiguei alguns dos algoritmos na lista, gostaria de mencionar dois.

Em Vignette, o desempenho em GPU é muito melhor, eu achei que isso foi usado invocando várias funções dentro de rs_cl.rsh. Se eu comentar essas funções, a CPU funcionará mais rápido (veja minha pergunta anterior no topo para um caso extremo). Então a questão é por que isso acontece. Em rs_cl.rsh, a maioria das funções são relacionadas à matemática, por ex. exp, log, cos, etc. Por que tal função roda muito mais rápido na GPU, isso ocorre porque a implementação dessas funções é realmente alta em paralelo ou apenas porque a implementação da versão é executada na GPU é melhor do que a versão é executada na CPU?

Outro exemplo é conv3x3 e conv5x5. Embora haja outras implementações mais inteligentes do que a versão do Google neste aplicativo de teste, acho que essa implementação pelo Google certamente não é ruim. Ele tenta minimizar a operação de adição e usa alguma função de facilitação de rs_cl.rsh, como convert_float4 (). Então, de relance, eu suponho que vai correr mais rápido na GPU. No entanto, ele é executado muito mais lentamente (no Nexus 4 e 5, ambos usando a GPU da Qualcomm). Acho que esse exemplo é muito representativo, já que na implementação, o algoritmo precisa acessar os pixels próximos ao pixel atual. Essa operação é bastante comum em muitos algoritmos de processamento de imagem. Se a implementação como a convolução 2D não puder ser mais rápida na GPU, suspeito que muitos outros algoritmos sofrerão o mesmo. Seria muito apreciado se você pudesse identificar onde está o problema e sugerir algumas maneiras de tornar esses algoritmos mais rápidos.

A questão mais geral é, dado o resultado do teste que mostrei, gostaria de perguntar que tipo de critérios as pessoas devem seguir para obter o melhor desempenho e evitar a degradação do desempenho, tanto quanto possível. Afinal, o objetivo do desempenho é o segundo objetivo mais importante do Renderscript e eu acho que a portabilidade do RS é muito boa.

Obrigado!