Funzioni e tipi di chiamata kernel RenderScript

Panoramica

La funzione rsForeach() può essere utilizzata per richiamare il kernel radice di uno script.

Le altre funzioni vengono utilizzate per ottenere le caratteristiche della chiamata a un kernel in esecuzione, come le dimensioni e gli indici correnti. Queste funzioni prendono un rs_kernel_context come argomento.

Riepilogo

Tipi
rs_per_ogni_strategia_t Ordine di elaborazione delle celle suggerito
rs_kernel Handle in una funzione kernel
contesto rs_kernel Handle in un contesto di chiamata kernel
rs_script_call_t Informazioni sull'iterazione delle celle
Funzioni
rsPerOgni Avvia un kernel
rsPerOgniInterno (API interna) Avvia un kernel nello script corrente (con il numero di slot)
rsPerOgniConOpzioni Avvia un kernel con opzioni
rsGetArray0 Indice nella dimensione Array0 per il contesto del kernel specificato
rsGetArray1 Indice nella dimensione Array1 per il contesto del kernel specificato
rsGetArray2 Indice nella dimensione Array2 per il contesto del kernel specificato
rsGetArray3 Indice nella dimensione Array3 per il contesto del kernel specificato
rsGetDimArray0 Dimensione della dimensione Array0 per il contesto del kernel specificato
rsGetDimArray1 Dimensione della dimensione Array1 per il contesto del kernel specificato
rsGetDimArray2 Dimensione della dimensione Array2 per il contesto del kernel specificato
rsGetDimArray3 Dimensione della dimensione Array3 per il contesto del kernel specificato
rsGetDimHasFaces Presenza di più di un volto per il contesto kernel specificato
rsGetDimLod Numero di livelli di dettaglio per il contesto kernel specificato
rsGetDimX Dimensione della dimensione X per il contesto del kernel specificato
rsGetDimY Dimensione della dimensione Y per il contesto del kernel specificato
rsGetDimZ Dimensione della dimensione Z per il contesto del kernel specificato
rsGetFace Coordinata della faccia per il contesto kernel specificato
rsGetLod Indice nella dimensione Livelli di dettaglio per il contesto kernel specificato

Tipi

rs_for_each_strategy_t : ordine di elaborazione di celle suggerito

Un'enumerazione con i seguenti valori:     

RS_FOR_EACH_STRATEGY_SERIAL = 0Preferisci regioni di memoria contigue.
RS_FOR_EACH_STRATEGY_DONT_CARE = 1Nessuna preferenza.
RS_FOR_EACH_STRATEGY_DST_LINEAR = 2Preferisci l'ora legale.
RS_FOR_EACH_STRATEGY_TILE_Small = 3Preferisco l'elaborazione di regioni rettangolari piccole.
RS_FOR_EACH_STRATEGY_TILE_MEDIUM = 4Preferisco l'elaborazione di regioni rettangolari di medie dimensioni.
RS_FOR_EACH_STRATEGY_TILE_LARGE = 5Preferisco l'elaborazione di regioni rettangolari grandi.

Questo tipo viene utilizzato per suggerire come il kernel chiamato deve eseguire l'iterazione sulle celle delle allocazioni. Questo è solo un suggerimento. Le implementazioni potrebbero non seguire il suggerimento.

Questa specifica può agevolare il comportamento di memorizzazione nella cache del kernel in esecuzione, ad esempio nella località della cache quando l'elaborazione viene distribuita su più core.

rs_kernel : handle in una funzione kernel

Un typedef: void*     Aggiunto al livello API 24

Tipo opaco per una funzione definita con l'attributo kernel. Un valore di questo tipo può essere utilizzato in una chiamata rsForeach per avviare un kernel.

rs_kernel_context : gestisci un contesto di chiamata del kernel

Un typedef di: const struct rs_kernel_context_t *     Aggiunto nel livello API 23

Il contesto del kernel contiene caratteristiche comuni delle allocazioni in fase di iterazione, come le dimensioni. Contiene inoltre gli indici utilizzati raramente della cella attualmente elaborata, come l'indice Array0 o il livello di dettaglio corrente.

Puoi accedere al contesto del kernel aggiungendo un parametro speciale denominato "context" di tipo rs_kernel_context alla funzione kernel. Per esempi, vedi rsGetDimX() e rsGetArray0().

rs_script_call_t : informazioni sull'iterazione delle celle

Una struttura con i seguenti campi:     

strategia rs_for_each_StrategyAttualmente ignorato. In futuro, verrà suggerita la strategia di iterazione delle celle.
uint32_t xStartIndice iniziale nella dimensione X.
uint32_t xEndIndice finale (esclusivo) nella dimensione X.
uint32_t yStartIndice iniziale nella dimensione Y.
uint32_t yEndIndice finale (esclusivo) nella dimensione Y.
uint32_t zStartIndice iniziale nella dimensione Z.
uint32_t zEndIndice finale (esclusivo) nella dimensione Z.
uint32_t arrayStartIndice iniziale nella dimensione Array0.
uint32_t arrayEndIndice finale (esclusivo) nella dimensione Array0.
uint32_t array1InizioIndice iniziale nella dimensione Array1.
uint32_t array1FineIndice finale (esclusivo) nella dimensione Array1.
uint32_t array2InizioIndice iniziale nella dimensione Array2.
uint32_t array2FineIndice finale (esclusivo) nella dimensione Array2.
uint32_t array3StartIndice iniziale nella dimensione Array3.
uint32_t array3EndIndice finale (esclusivo) nella dimensione Array3.

Questa struttura viene utilizzata per fornire informazioni sull'iterazione a una chiamata rsForeach. Attualmente è utilizzato per limitare l'elaborazione a un sottoinsieme di celle. Nelle versioni future, verrà inoltre utilizzato per fornire suggerimenti su come eseguire al meglio l'iterazione nelle celle.

I campi Start sono inclusivi, mentre i campi Fine sono esclusivi. Ad esempio, per eseguire l'iterazione delle celle 4, 5, 6 e 7 della dimensione X, imposta xStart su 4 e xEnd su 8.

Funzioni

rsForeach : avvia un kernel

void rsForYear(kernel rs_kernel, ... ...); Aggiunto al livello API 24
void rsForeach(script rs_script, input rs_allocation, output rs_allocation); Livelli API 14-23
void rsForeach(script rs_script, input rs_allocation, output rs_allocation, const void* usrData); Rimossa dal livello API 14 e successivi
void rsForOgni(script rs_script, input rs_allocation, output rs_allocation, const void* usrData, const rs_script_call_t* sc); Rimossa dal livello API 14 e successivi
void rsForeach(script rs_script, input rs_allocation, output rs_allocation, const void* usrData, size_t usrDataLen); Livelli API 14-20
void rsForeach(script rs_script, input rs_allocation, output rs_allocation, const void* usrData, size_t usrDataLen, const rs_script_call_t* sc); Livelli API 14-20
Parametri
scriptScript da chiamare.
ingressoAllocazione ai dati di origine da.
outputAllocazione in cui scrivere la data.
Dati usrDati definiti dall'utente da passare allo script. Può essere NULL.
scInformazioni di controllo aggiuntive utilizzate per selezionare una sottoregione dell'allocazione da elaborare o suggerire una strategia per passeggiate. Può essere NULL.
usrDataLenDimensioni della struttura userData. Verrà utilizzata per eseguire una copia superficiale dei dati, se necessario.
kernelDesignatore di funzione di una funzione definita con l'attributo kernel.
Allocazioni di input e output

Esegue il kernel su zero o più allocazioni di input. Vengono passati dopo l'argomento rs_kernel. Se il kernel specificato restituisce un valore, è necessario specificare un'allocazione di output come ultimo argomento. Tutte le allocazioni di input e quella di output, se esistente, devono avere le stesse dimensioni.

Questa è una funzione sincrona. Una chiamata a questa funzione restituisce solo dopo che tutto il lavoro è stato completato per tutte le celle delle allocazioni dell'input. Se la funzione kernel restituisce un valore qualsiasi, la chiamata attende che tutti i risultati siano stati scritti nell'allocazione dell'output.

Fino al livello API 23, il kernel viene specificato implicitamente come kernel denominato "root" nello script specificato ed è possibile utilizzare una sola allocazione di input. A partire dal livello API 24, è possibile utilizzare una funzione kernel arbitrario, come specificato dall'argomento kernel. L'argomento di script viene rimosso. Il kernel deve essere definito nello script corrente. Inoltre, è possibile utilizzare più di un input.

Ad es.
float __attribute__((kernel)) square(float a) {
  return a * a;
}

void compute(rs_allocation ain, rs_allocation aout) {
  rsForEach(square, ain, aout);
}

rsForOgniInternal : (API interna) avvia un kernel nello script corrente (con il numero di slot)

void rsForUniqueInternal(int slot, rs_script_call_t* opzioni, int hasOutput, int numInputs, rs_allocation* alloc); Aggiunto al livello API 24
Parametri
spazio
opzioni
hasOutputIndica se il kernel genera output
numInputNumero di allocazioni di input
allocAllocazioni di input e output

API interna per avviare un kernel.

rsForYearWithOptions : avvia un kernel con opzioni

void rsForUniqueWithOptions(kernel rs_kernel, opzioni rs_script_call_t*, ... ...); Aggiunto al livello API 24
Parametri
kernelDesignatore di funzione di una funzione definita con l'attributo kernel.
opzioniOpzioni di avvio
Allocazioni di input e output

Avvia il kernel in modo simile a rsForOgni. Tuttavia, anziché elaborare tutte le celle nell'input, questa funzione elabora solo le celle nel sottospazio dello spazio dell'indice specificato nelle opzioni. Con lo spazio dell'indice esplicitamente specificato dalle opzioni, non è richiesta alcuna allocazione di input o output per il lancio del kernel mediante questa API. Se vengono trasmesse le allocazioni, devono corrispondere al numero di argomenti e al valore restituito atteso dalla funzione kernel. L'allocazione dell'output è presente solo se il kernel ha un valore restituito non void.

Ad es.
rs_script_call_t opts = {0};
opts.xStart = 0;
opts.xEnd = dimX;
opts.yStart = 0;
opts.yEnd = dimY / 2;
rsForEachWithOptions(foo, &opts, out, out);

rsGetArray0 : indice nella dimensione Array0 per il contesto del kernel specificato

uint32_t rsGetArray0(rs_kernel_context contesto); Aggiunto al livello API 23

Restituisce l'indice nella dimensione Array0 della cella in fase di elaborazione, come specificato dal contesto del kernel fornito.

Il contesto kernel contiene caratteristiche comuni delle allocazioni sottoposte a iterazione e indici utilizzati raramente, come l'indice Array0.

Puoi accedere al contesto del kernel aggiungendo un parametro speciale denominato "context" di tipo rs_kernel_context alla funzione kernel. Ad es.
short RS_KERNEL myKernel(short value, uint32_t x, rs_kernel_context context) {
  // The current index in the common x, y, z dimensions are accessed by
  // adding these variables as arguments. For the more rarely used indices
  // to the other dimensions, extract them from the kernel context:
  uint32_t index_a0 = rsGetArray0(context);
  //...
}

Questa funzione restituisce 0 se la dimensione Array0 non è presente.

rsGetArray1 : indice nella dimensione Array1 per il contesto del kernel specificato

uint32_t rsGetArray1(rs_kernel_context contesto); Aggiunto al livello API 23

Restituisce l'indice nella dimensione Array1 della cella in fase di elaborazione, come specificato dal contesto del kernel fornito. Consulta rsGetArray0() per una spiegazione del contesto.

Restituisce 0 se la dimensione Array1 non è presente.

rsGetArray2 : indice nella dimensione Array2 per il contesto del kernel specificato

uint32_t rsGetArray2(rs_kernel_context contesto); Aggiunto al livello API 23

Restituisce l'indice nella dimensione Array2 della cella in fase di elaborazione, come specificato dal contesto del kernel fornito. Consulta rsGetArray0() per una spiegazione del contesto.

Restituisce 0 se la dimensione Array2 non è presente.

rsGetArray3 : indice nella dimensione Array3 per il contesto del kernel specificato

uint32_t rsGetArray3(rs_kernel_context); Aggiunto al livello API 23

Restituisce l'indice nella dimensione Array3 della cella in fase di elaborazione, come specificato dal contesto del kernel fornito. Consulta rsGetArray0() per una spiegazione del contesto.

Restituisce 0 se la dimensione Array3 non è presente.

rsGetDimArray0 : dimensione della dimensione Array0 per il contesto del kernel specificato

uint32_t rsGetDimArray0(rs_kernel_context contesto); Aggiunto al livello API 23

Restituisce la dimensione della dimensione Array0 per il contesto del kernel specificato. Consulta rsGetDimX() per una spiegazione del contesto.

Restituisce 0 se la dimensione Array0 non è presente.

rsGetDimArray1 : dimensione della dimensione Array1 per il contesto del kernel specificato

uint32_t rsGetDimArray1(rs_kernel_context); Aggiunto al livello API 23

Restituisce la dimensione della dimensione Array1 per il contesto del kernel specificato. Consulta rsGetDimX() per una spiegazione del contesto.

Restituisce 0 se la dimensione Array1 non è presente.

rsGetDimArray2 : dimensione della dimensione Array2 per il contesto del kernel specificato

uint32_t rsGetDimArray2(rs_kernel_context contesto); Aggiunto al livello API 23

Restituisce la dimensione della dimensione Array2 per il contesto del kernel specificato. Consulta rsGetDimX() per una spiegazione del contesto.

Restituisce 0 se la dimensione Array2 non è presente.

rsGetDimArray3 : dimensione della dimensione Array3 per il contesto del kernel specificato

uint32_t rsGetDimArray3(rs_kernel_context contesto); Aggiunto al livello API 23

Restituisce la dimensione della dimensione Array3 per il contesto kernel specificato. Consulta rsGetDimX() per una spiegazione del contesto.

Restituisce 0 se la dimensione Array3 non è presente.

rsGetDimHasFaces : presenza di più di un volto per il contesto del kernel specificato

bool rsGetDimHasFaces(rs_kernel_context contesto); Aggiunto al livello API 23
Ritorni
Restituisce true se è presente più di un volto, false negli altri casi.

Se il kernel esegue l'iterazione su una mappa cubica, questa funzione restituisce true se è presente più di una faccia. In tutti gli altri casi, restituisce false. Per una spiegazione del contesto, consulta rsGetDimX().

rsAllocationGetDimFaces() è simile, ma restituisce 0 o 1 invece di bool.

rsGetDimLod : numero di livelli di dettaglio per il contesto del kernel specificato

uint32_t rsGetDimLod(rs_kernel_context contesto); Aggiunto al livello API 23

Restituisce il numero di livelli di dettaglio per il contesto del kernel specificato. È utile per le mipmap. Consulta rsGetDimX() per una spiegazione del contesto.

Restituisce 0 se il livello di dettaglio non è utilizzato.

rsAllocationGetDimLOD() è simile, ma restituisce 0 o 1 invece del numero effettivo di livelli.

rsGetDimX : dimensioni della dimensione X per il contesto del kernel specificato

uint32_t rsGetDimX(rs_kernel_context contesto); Aggiunto al livello API 23

Restituisce la dimensione della dimensione X per il contesto del kernel specificato.

Il contesto kernel contiene caratteristiche comuni delle allocazioni sottoposte a iterazione e indici utilizzati raramente, come l'indice Array0.

Puoi accedervi aggiungendo un parametro speciale denominato "context" di tipo rs_kernel_context alla funzione kernel. Ad es.
int4 RS_KERNEL myKernel(int4 value, rs_kernel_context context) {
  uint32_t size = rsGetDimX(context); //...

Per ottenere la dimensione di allocazione specifica, utilizza rsAllocationGetDimX().

rsGetDimY : dimensione della dimensione Y per il contesto del kernel specificato

uint32_t rsGetDimY(rs_kernel_context); Aggiunto al livello API 23

Restituisce la dimensione della dimensione X per il contesto del kernel specificato. Consulta rsGetDimX() per una spiegazione del contesto.

Restituisce 0 se la dimensione Y non è presente.

Per ottenere la dimensione di allocazione specifica, utilizza rsAllocationGetDimY().

rsGetDimZ : dimensione della dimensione Z per il contesto del kernel specificato

uint32_t rsGetDimZ(rs_kernel_context contesto); Aggiunto al livello API 23

Restituisce la dimensione della dimensione Z per il contesto del kernel specificato. Consulta rsGetDimX() per una spiegazione del contesto.

Restituisce 0 se la dimensione Z non è presente.

Per ottenere la dimensione di allocazione specifica, utilizza rsAllocationGetDimZ().

rsGetFace : coordinata della faccia per il contesto del kernel specificato

Restituisce il volto in cui si trova la cella in fase di elaborazione, come specificato dal contesto del kernel fornito. Consulta rsGetArray0() per una spiegazione del contesto.

Restituisce RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X se la dimensione faccia non è presente.

rsGetLod : indice nella dimensione Livelli di dettaglio per il contesto del kernel specificato

uint32_t rsGetLod(contesto rs_kernel_context); Aggiunto al livello API 23

Restituisce l'indice nella dimensione Livelli di dettaglio della cella in fase di elaborazione, come specificato dal contesto del kernel fornito. Consulta rsGetArray0() per una spiegazione del contesto.

Restituisce 0 se la dimensione Livelli di dettaglio non è presente.