A renderização do script falha no driver habilitado para GPU se USAGE_SHARED
Estamos usando o renderscript para processamento de dsp de áudio. É simples e melhora significativamente o desempenho para o nosso caso de uso. Mas encontramos um problema irritante comUSAGE_SHARED
em dispositivos que possuem driver personalizado com a execução da GPU ativada.
Como você deve saber,USAGE_SHARED
O flag faz a alocação do rendercript para reutilizar a memória fornecida sem precisar criar uma cópia dela. Como conseqüência, não apenas economiza memória, no nosso caso, melhora o desempenho para o nível desejado.
O código a seguir comUSAGE_SHARED
funciona bem no driver renderscript padrão (libRSDriver.so
) Com driver personalizado (libRSDriver_adreno.so
) USAGE_SHARED
não reutiliza a memória fornecida e, portanto, os dados.
Este é o código que faz uso deUSAGE_SHARED
e chama o kernel do renderscript
void process(float* in1, float* in2, float* out, size_t size) {
sp<RS> rs = new RS();
rs->init(app_cache_dir);
sp<const Element> e = Element::F32(rs);
sp<const Type> t = Type::create(rs, e, size, 0, 0);
sp<Allocation> in1Alloc = Allocation::createTyped(
rs, t,
RS_ALLOCATION_MIPMAP_NONE,
RS_ALLOCATION_USAGE_SCRIPT | RS_ALLOCATION_USAGE_SHARED,
in1);
sp<Allocation> in2Alloc = Allocation::createTyped(
rs, t,
RS_ALLOCATION_MIPMAP_NONE,
RS_ALLOCATION_USAGE_SCRIPT | RS_ALLOCATION_USAGE_SHARED,
in2);
sp<Allocation> outAlloc = Allocation::createTyped(
rs, t,
RS_ALLOCATION_MIPMAP_NONE,
RS_ALLOCATION_USAGE_SCRIPT | RS_ALLOCATION_USAGE_SHARED,
out);
ScriptC_x* rsX = new ScriptC_x(rs);
rsX->set_in1Alloc(in1Alloc);
rsX->set_in2Alloc(in2Alloc);
rsX->set_size(size);
rsX->forEach_compute(in1Alloc, outAlloc);
}
NOTA: Essa variação deAllocation::createTyped()
não é mencionado na documentação, mas o códigorsCppStructs.h
tem. Esse é o método da fábrica de alocação que permite fornecer ponteiros de apoio e respeitarUSAGE_SHARED
bandeira. É assim que é declarado:
/**
* Creates an Allocation for use by scripts with a given Type and a backing pointer. For use
* with RS_ALLOCATION_USAGE_SHARED.
* @param[in] rs Context to which the Allocation will belong
* @param[in] type Type of the Allocation
* @param[in] mipmaps desired mipmap behavior for the Allocation
* @param[in] usage usage for the Allocation
* @param[in] pointer existing backing store to use for this Allocation if possible
* @return new Allocation
*/
static sp<Allocation> createTyped(
const sp<RS>& rs, const sp<const Type>& type,
RsAllocationMipmapControl mipmaps,
uint32_t usage,
void * pointer);
Este é o kernel renderscript
rs_allocation in1Alloc, in2Alloc;
uint32_t size;
// JUST AN EXAMPLE KERNEL
// Not using reduction kernel since it is only available in later API levels.
// Not sure if support library helps here. Anyways, unrelated to the current problem
float compute(float ignored, uint32_t x) {
float result = 0.0f;
for (uint32_t i=0; i<size; i++) {
result += rsGetElementAt_float(in1Alloc, x) * rsGetElementAt_float(in2Alloc, size-i-1); // just an example computation
}
return result;
}
Como mencionado,out
não possui nenhum resultado do cálculo.syncAll(RS_ALLOCATION_USAGE_SHARED)
também não ajudou.
O seguinte funciona embora (mas muito mais lento)
void process(float* in1, float* in2, float* out, size_t size) {
sp<RS> rs = new RS();
rs->init(app_cache_dir);
sp<const Element> e = Element::F32(rs);
sp<const Type> t = Type::create(rs, e, size, 0, 0);
sp<Allocation> in1Alloc = Allocation::createTyped(rs, t);
in1Alloc->copy1DFrom(in1);
sp<Allocation> in2Alloc = Allocation::createTyped(rs, t);
in2Alloc->copy1DFrom(in2);
sp<Allocation> outAlloc = Allocation::createTyped(rs, t);
ScriptC_x* rsX = new ScriptC_x(rs);
rsX->set_in1Alloc(in1Alloc);
rsX->set_in2Alloc(in2Alloc);
rsX->set_size(size);
rsX->forEach_compute(in1Alloc, outAlloc);
outAlloc->copy1DTo(out);
}
A cópia faz com que funcione, mas em nossos testes, a cópia para frente e para trás prejudica significativamente o desempenho.
Se desativarmos a execução da GPU por meio dedebug.rs.default-CPU-driver
propriedade do sistema, pudemos ver que o driver personalizado funciona bem com o desempenho desejado.
O alinhamento da memória fornecida ao renderscript para 16,32, .. ou 1024, etc, não ajudou a fazer o driver personalizado respeitar USAGE_SHARED.
Pergunta, questãoPortanto, nossa pergunta é a seguinte: como fazer esse kernel funcionar para dispositivos que usam driver de renderização personalizado que permite a execução de GPU?