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 = 0 | Preferisci regioni di memoria contigue. |
|---|---|
| RS_FOR_EACH_STRATEGY_DONT_CARE = 1 | Nessuna preferenza. |
| RS_FOR_EACH_STRATEGY_DST_LINEAR = 2 | Preferisci l'ora legale. |
| RS_FOR_EACH_STRATEGY_TILE_Small = 3 | Preferisco l'elaborazione di regioni rettangolari piccole. |
| RS_FOR_EACH_STRATEGY_TILE_MEDIUM = 4 | Preferisco l'elaborazione di regioni rettangolari di medie dimensioni. |
| RS_FOR_EACH_STRATEGY_TILE_LARGE = 5 | Preferisco 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_Strategy | Attualmente ignorato. In futuro, verrà suggerita la strategia di iterazione delle celle. |
|---|---|
| uint32_t xStart | Indice iniziale nella dimensione X. |
| uint32_t xEnd | Indice finale (esclusivo) nella dimensione X. |
| uint32_t yStart | Indice iniziale nella dimensione Y. |
| uint32_t yEnd | Indice finale (esclusivo) nella dimensione Y. |
| uint32_t zStart | Indice iniziale nella dimensione Z. |
| uint32_t zEnd | Indice finale (esclusivo) nella dimensione Z. |
| uint32_t arrayStart | Indice iniziale nella dimensione Array0. |
| uint32_t arrayEnd | Indice finale (esclusivo) nella dimensione Array0. |
| uint32_t array1Inizio | Indice iniziale nella dimensione Array1. |
| uint32_t array1Fine | Indice finale (esclusivo) nella dimensione Array1. |
| uint32_t array2Inizio | Indice iniziale nella dimensione Array2. |
| uint32_t array2Fine | Indice finale (esclusivo) nella dimensione Array2. |
| uint32_t array3Start | Indice iniziale nella dimensione Array3. |
| uint32_t array3End | Indice 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
| script | Script da chiamare. |
|---|---|
| ingresso | Allocazione ai dati di origine da. |
| output | Allocazione in cui scrivere la data. |
| Dati usr | Dati definiti dall'utente da passare allo script. Può essere NULL. |
| sc | Informazioni di controllo aggiuntive utilizzate per selezionare una sottoregione dell'allocazione da elaborare o suggerire una strategia per passeggiate. Può essere NULL. |
| usrDataLen | Dimensioni della struttura userData. Verrà utilizzata per eseguire una copia superficiale dei dati, se necessario. |
| kernel | Designatore 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 | |
| hasOutput | Indica se il kernel genera output |
| numInput | Numero di allocazioni di input |
| alloc | Allocazioni 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
| kernel | Designatore di funzione di una funzione definita con l'attributo kernel. |
|---|---|
| opzioni | Opzioni 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
| rs_allocation_cubemap_face rsGetFace(contesto rs_kernel_context); | Aggiunto al livello API 23 |
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.