Classe array_view

Rappresenta una visualizzazione N dimensionale sui dati contenuti in un altro contenitore.

Sintassi

template <
    typename value_type,
    int _Rank = 1
>
class array_view : public _Array_view_base<_Rank, sizeof(value_type)/sizeof(int)>;

template <
    typename value_type,
    int _Rank
>
class array_view<const value_type, _Rank> : public _Array_view_base<_Rank, sizeof(value_type)/sizeof(int)>;

Parametri

value_type
Tipo di dati degli elementi nell'oggetto array_view .

_Rango
Classificazione dell'oggetto array_view .

Membri

Costruttori pubblici

Metodi pubblici

Operatori pubblici

Costanti pubbliche

Membri dati

Osservazioni:

La array_view classe rappresenta una visualizzazione nei dati contenuti in un oggetto matrice o in una sottosezione di un array oggetto .

È possibile accedere all'oggetto array_view in cui si trovano i dati di origine (localmente) o su un acceleratore diverso o su un dominio di coerenza (in remoto). Quando si accede all'oggetto in modalità remota, le visualizzazioni vengono copiate e memorizzate nella cache in base alle esigenze. Ad eccezione degli effetti della memorizzazione nella cache automatica, array_view gli oggetti hanno un profilo di prestazioni simile a quello degli array oggetti . Quando si accede ai dati tramite visualizzazioni, si verifica un leggero calo delle prestazioni.

Esistono tre scenari di utilizzo remoto:

• Un riferimento a un puntatore della memoria di sistema viene passato tramite una chiamata parallel_for_each a un acceleratore ed è acceduto sull'acceleratore.

• Una visualizzazione di una matrice che si trova su un acceleratore viene passata tramite una parallel_for_each chiamata a un altro acceleratore e vi si accede.

• È possibile accedere a una vista di un array posizionato su un acceleratore dalla CPU.

In uno di questi scenari, le viste a cui si fa riferimento vengono copiate dal runtime nella posizione remota e, se modificate dalle chiamate all'oggetto array_view , vengono copiate nuovamente nella posizione locale. Il runtime potrebbe ottimizzare il processo di copia delle modifiche, potrebbe copiare solo gli elementi modificati o copiare anche parti non modificate. Gli oggetti sovrapposti array_view in un'origine dati non sono garantiti per mantenere l'integrità referenziale in una posizione remota.

È necessario sincronizzare qualsiasi accesso multithreading alla stessa origine dati.

Il runtime garantisce le garanzie seguenti relative alla memorizzazione nella cache dei dati negli array_view oggetti :

• Tutti gli accessi ben sincronizzati a un oggetto array e a un oggetto array_view ad esso associato, secondo l'ordine del programma, obbediscono a una relazione di precedenza seriale.

• Tutti gli accessi ben sincronizzati agli oggetti sovrapposti array_view sullo stesso acceleratore su un singolo array oggetto vengono aliasati tramite l'oggetto array . Inducono una relazione di precedenza totale che obbedisce all'ordine del programma. Non è presente alcuna memorizzazione nella cache. Se gli array_view oggetti vengono eseguiti su acceleratori diversi, l'ordine di accesso non è definito, creando una condizione di competizione (race condition).

Quando si crea un array_view oggetto usando un puntatore in memoria di sistema, è necessario modificare l'oggetto di visualizzazione array_view solo tramite il array_view puntatore. In alternativa, è necessario chiamare refresh() su uno degli array_view oggetti collegati al puntatore di sistema, se la memoria nativa sottostante viene modificata direttamente, anziché tramite l'oggetto array_view .

Entrambe le azioni notificano all'oggetto array_view che la memoria nativa sottostante viene modificata e che tutte le copie che si trovano in un acceleratore non sono aggiornate. Se si seguono queste linee guida, le viste basate su puntatore sono identiche a quelle fornite alle viste di matrici parallele di dati.

Gerarchia di ereditarietà

_Array_view_shape

_Array_view_base

array_view

Requisiti

Intestazione: amp.h

Spazio dei nomi: Concurrency

~array_view

Elimina definitivamente l'oggetto array_view .

~array_view()restrict(amp,cpu);

array_view

Inizializza una nuova istanza della classe array_view.

array_view(
    array<value_type, _Rank>& _Src)restrict(amp,cpu);

array_view(
    const array_view& _Other)restrict(amp,cpu);

explicit array_view(
    const Concurrency::extent<_Rank>& _Extent) restrict(cpu);

template <
    typename _Container
>
array_view(
    const Concurrency::extent<_Rank>& _Extent,
    _Container& _Src) restrict(cpu);

array_view(
    const Concurrency::extent<_Rank>& _Extent,
    value_type* _Src)restrict(amp,cpu);

explicit array_view(
    int _E0) restrict(cpu);

template <
    typename _Container
>
explicit array_view(
    _Container& _Src,
    typename std::enable_if<details::_Is_container<_Container>::type::value, void **>::type = 0) restrict(cpu);

template <
    typename _Container
>
explicit array_view(
    int _E0,
    _Container& _Src) restrict(cpu);

explicit array_view(
    int _E0,
    int _E1) __CPU_ONLY;

template <
    typename _Container
>
explicit array_view(
    int _E0,
    int _E1,
    _Container& _Src) restrict(cpu);

explicit array_view(
    int _E0,
    int _E1,
    int _E2) __CPU_ONLY;

template <
    typename _Container
>
explicit array_view(
    int _E0,
    int _E1,
    int _E2,
    _Container& _Src);

explicit array_view(
    int _E0,
    _In_ value_type* _Src)restrict(amp,cpu);

template <
    typename _Arr_type,
    int _Size
>
explicit array_view(
    _In_ _Arr_type (& _Src) [_Size]) restrict(amp,cpu);

explicit array_view(
    int _E0,
    int _E1,
    _In_ value_type* _Src)restrict(amp,cpu);

explicit array_view(
    int _E0,
    int _E1,
    int _E2,
    _In_ value_type* _Src)restrict(amp,cpu);

array_view(
    const array<value_type, _Rank>& _Src)restrict(amp,cpu);

array_view(
    const array_view<value_type, _Rank>& _Src)restrict(amp,cpu);

array_view(
    const array_view<const value_type, _Rank>& _Src)restrict(amp,cpu);

template <
    typename _Container
>
array_view(
    const Concurrency::extent<_Rank>& _Extent,
    const _Container& _Src) restrict(cpu);

template <
    typename _Container
>
explicit array_view(
    const _Container& _Src,
    typename std::enable_if<details::_Is_container<_Container>::type::value, void **>::type = 0) restrict(cpu);

array_view(
    const Concurrency::extent<_Rank>& _Extent,
    const value_type* _Src)restrict(amp,cpu);

template <
    typename _Arr_type,
    int _Size
>
explicit array_view(
    const _In_ _Arr_type (& _Src) [_Size]) restrict(amp,cpu);

template <
    typename _Container
>
array_view(
    int _E0,
    const _Container& _Src);

template <
    typename _Container
>
array_view(
    int _E0,
    int _E1,
    const _Container& _Src);

template <
    typename _Container
>
array_view(
    int _E0,
    int _E1,
    int _E2,
    const _Container& _Src);

array_view(
    int _E0,
    const value_type* _Src)restrict(amp,cpu);

array_view(
    int _E0,
    int _E1,
    const value_type* _Src) restrict(amp,cpu);

array_view(
    int _E0,
    int _E1,
    int _E2,
    const value_type* _Src) restrict(amp,cpu);

Parametri

_Arr_type
Tipo di elemento di una matrice di tipo C da cui vengono forniti i dati.

_Contenitore
Argomento modello che deve specificare un contenitore lineare che supporti i membri data() e size().

_E0
Componente più significativo dell'estensione di questa sezione.

_E1
La componente immediatamente meno significativa dell'estensione di questa sezione.

_E2
Componente meno significativo dell'estensione di questa sezione.

_Estensione
L'estensione in ogni dimensione di questo array_view.

_Altro
Oggetto di tipo array_view<T,N> da cui inizializzare il nuovo array_view.

_Dimensione
Dimensioni di una matrice in stile C da cui vengono forniti i dati.

_Src
Puntatore ai dati di origine che verranno copiati nella nuova matrice.

copy_to

Copia il contenuto dell'oggetto array_view nell'oggetto di destinazione specificato chiamando copy(*this, dest).

void copy_to(
    array<value_type, _Rank>& _Dest) const;

void copy_to(
    array_view<value_type, _Rank>& _Dest) const;

Parametri

_Dest
L'oggetto su cui copiare.

data

Restituisce un puntatore ai dati grezzi dell'oggetto array_view.

value_type* data() const restrict(amp,
    cpu);

const value_type* data() const restrict(amp,
    cpu);

Valore restituito

Un puntatore ai dati grezzi dell'oggetto array_view.

scartare_dati

Scarta i dati correnti sottostanti questa visualizzazione. Si tratta di un hint di ottimizzazione per il runtime usato per evitare di copiare il contenuto corrente della visualizzazione in una destinazione accelerator_view su cui si accede e il relativo uso è consigliato se il contenuto esistente non è necessario. Questo metodo è un metodo no-op quando viene usato in un contesto restrict(amp)

void discard_data() const restrict(cpu);

estensione

Ottiene l'oggetto extent che definisce la forma dell'oggetto array_view.

__declspec(property(get= get_extent)) Concurrency::extent<_Rank> extent;

get_extent

Restituisce l'oggetto extent dell'oggetto array_view .

Concurrency::extent<_Rank> get_extent() const restrict(cpu, amp);

Valore restituito

Oggetto extent dell'oggetto array_view

get_ref

Ottenere un riferimento all'elemento indicizzato da _Index. A differenza degli altri operatori di indicizzazione per l'accesso al array_view nella CPU, questo metodo non sincronizza in modo implicito il contenuto di questo array_view con la CPU. Dopo l'accesso al array_view in una posizione remota o l'esecuzione di un'operazione di copia che coinvolge questo array_view gli utenti sono responsabili della sincronizzazione esplicita del array_view alla CPU prima di chiamare questo metodo. In caso contrario, si verifica un comportamento non definito.

value_type& get_ref(
    const index<_Rank>& _Index) const restrict(amp, cpu);

Parametri

_Indice
Indice.

Valore restituito

Riferimento all'elemento indicizzato da _Index

ottenere_visione_acceleratore_sorgente

Restituisce l'accelerator_view in cui si trova l'origine dati dell'array_view. Se il array_view non dispone di un'origine dati, questa API genera un runtime_exception

accelerator_view get_source_accelerator_view() const;

Valore restituito

operator()

Restituisce il valore dell'elemento specificato dal parametro o dai parametri.

value_type& operator() (
    const index<_Rank>& _Index) const restrict(amp,cpu);

typename details::_Projection_result_type<value_type,_Rank>::_Result_type operator() (
    int _I) const restrict(amp,cpu);

value_type& operator() (
    int _I0,
    int _I1) const restrict(amp,cpu);

value_type& operator() (
    int _I0,
    int _I1,
    int _I2) const restrict(amp,cpu);

typename details::_Projection_result_type<value_type,_Rank>::_Const_result_type operator() (
    int _I) const restrict(amp,cpu);

Parametri

_Indice
Posizione dell'elemento.

_I0
L'indice nella prima dimensione.

_I1
L'indice nella seconda dimensione.

_I2
Indice nella terza dimensione.

_I
Posizione dell'elemento.

Valore restituito

Valore dell'elemento specificato dal parametro o dai parametri.

operator[]

Restituisce l'elemento specificato dai parametri.

typename details::_Projection_result_type<value_type,_Rank>::_Const_result_type operator[] (
    int _I) const restrict(amp,cpu);

value_type& operator[] (
    const index<_Rank>& _Index) const restrict(amp,cpu);

Parametri

_Indice
Indice.

_I
Indice.

Valore restituito

Il valore dell'elemento all'indice specificato, oppure una proiezione di array_view sulla dimensione più significativa.

operator=

Copia il contenuto dell'oggetto specificato array_view in questo oggetto.

array_view& operator= (
    const array_view& _Other) restrict(amp,cpu);

array_view& operator= (
    const array_view<value_type, _Rank>& _Other) restrict(amp,cpu);

Parametri

_Altro
Oggetto array_view da cui copiare.

Valore restituito

Riferimento a questo array_view oggetto.

rank

Archivia la classificazione dell'oggetto array_view .

static const int rank = _Rank;

aggiorna

Notifica all'oggetto array_view che la memoria associata è stata modificata all'esterno dell'interfaccia array_view . Una chiamata a questo metodo rende tutte le informazioni memorizzate nella cache obsolete.

void refresh() const restrict(cpu);

reinterpret_as

Reinterpreta il array_view tramite un array_view unidimensionale, che come opzione può avere un tipo di valore diverso rispetto al array_view di origine.

Sintassi

template <
    typename _Value_type2
>
array_view< _Value_type2, _Rank> reinterpret_as() const restrict(amp,cpu);

template <
    typename _Value_type2
>
array_view<const _Value_type2, _Rank> reinterpret_as() const restrict(amp,cpu);

Parametri

_Value_type2
Tipo di dati del nuovo array_view oggetto.

Valore restituito

Oggetto array_view o oggetto const array_view basato su questo array_view, con il tipo di elemento convertito da T a _Value_type2 e il grado ridotto da N a 1.

Osservazioni:

A volte è utile visualizzare una matrice multidimensionale come matrice lineare unidimensionale, che può avere un tipo di valore diverso rispetto alla matrice di origine. È possibile ottenere questo risultato su un array_view oggetto usando questo metodo.

Avviso Reinterpretare un oggetto array_view con un tipo di valore diverso è un'operazione potenzialmente pericolosa. Questa funzionalità deve essere usata con attenzione.

Ecco un esempio:

struct RGB { float r; float g; float b; };

array<RGB,3>  a = ...;
array_view<float,1> v = a.reinterpret_as<float>();

assert(v.extent == 3*a.extent);

sezione

Restituisce una sottosezione dell'oggetto array_view all'origine specificata e, facoltativamente, con la dimensione specificata.

array_view section(
    const Concurrency::index<_Rank>& _Section_origin,
    const Concurrency::extent<_Rank>& _Section_extent) const restrict(amp,cpu);

array_view section(
    const Concurrency::index<_Rank>& _Idx) const restrict(amp,cpu);

array_view section(
    const Concurrency::extent<_Rank>& _Ext) const restrict(amp,cpu);

array_view section(
    int _I0,
    int _E0) const restrict(amp,cpu);

array_view section(
    int _I0,
    int _I1,
    int _E0,
    int _E1) const restrict(amp,cpu);

array_view section(
    int _I0,
    int _I1,
    int _I2,
    int _E0,
    int _E1,
    int _E2) const restrict(amp,cpu);

Parametri

_E0
Componente più significativo dell'estensione di questa sezione.

_E1
La componente immediatamente meno significativa dell'estensione di questa sezione.

_E2
Componente meno significativo dell'estensione di questa sezione.

_Ext
Oggetto extent che specifica l'extent della sezione. L'origine è 0.

_Idx
Oggetto indice che specifica la posizione dell'origine. La sottosezione è il resto dell'estensione.

_I0
Componente più significativo dell'origine di questa sezione.

_I1
Il secondo componente più significativo dell'origine di questa sezione.

_I2
Componente meno significativo dell'origine di questa sezione.

_Rango
Classificazione della sezione.

_Section_extent
Oggetto extent che specifica l'extent della sezione.

_Section_origin
Oggetto indice che specifica la posizione dell'origine.

Valore restituito

Sottosezione dell'oggetto array_view in corrispondenza dell'origine specificata e, facoltativamente, con l'estensione specificata. Quando viene specificato solo l'oggetto index , la sottosezione contiene tutti gli elementi nell'extent associato con indici maggiori degli indici degli elementi nell'oggetto index .

visualizzazione_acceleratore_origine

Ottiene l'accelerator_view di origine con cui è associato questo array_view.

__declspec(property(get= get_source_accelerator_view)) accelerator_view source_accelerator_view;

sincronizzare

Sincronizza le eventuali modifiche apportate all'oggetto con i array_view relativi dati di origine.

void synchronize(access_type _Access_type = access_type_read) const restrict(cpu);

void synchronize() const restrict(cpu);

Parametri

_Tipo_di_accesso
Il access_type previsto nel accelerator_view di destinazione. Questo parametro ha un valore predefinito di access_type_read.

synchronize_async

Sincronizza in modo asincrono tutte le modifiche apportate all'oggetto array_view ai dati di origine.

concurrency::completion_future synchronize_async(access_type _Access_type = access_type_read) const restrict(cpu);

concurrency::completion_future synchronize_async() const restrict(cpu);

Parametri

_Tipo_di_accesso
Il access_type previsto sul accelerator_view di destinazione. Questo parametro ha un valore predefinito di access_type_read.

Valore restituito

Futuro su cui attendere il completamento dell'operazione.

sincronizzare_con

Sincronizza tutte le modifiche apportate a questo array_view con il accelerator_view specificato.

void synchronize_to(
    const accelerator_view& _Accl_view,
    access_type _Access_type = access_type_read) const restrict(cpu);

void synchronize_to(
    const accelerator_view& _Accl_view) const restrict(cpu);

Parametri

_Accl_view
Il accelerator_view di destinazione in cui eseguire la sincronizzazione.

_Tipo_accesso
Il access_type desiderato nella "accelerator_view" di destinazione. Questo parametro ha un valore predefinito di access_type_read.

synchronize_to_async

Sincronizza in modo asincrono tutte le modifiche apportate a questa array_view con il accelerator_view specificato.

concurrency::completion_future synchronize_to_async(
    const accelerator_view& _Accl_view,
    access_type _Access_type = access_type_read) const restrict(cpu);

concurrency::completion_future synchronize_to_async(
    const accelerator_view& _Accl_view) const restrict(cpu);

Parametri

_Accl_view
Il accelerator_view di destinazione in cui eseguire la sincronizzazione.

_Tipo_di_accesso
Il tipo di accesso desiderato sull'accelerator_view di destinazione. Questo parametro ha un valore predefinito di access_type_read.

Valore restituito

Futuro su cui attendere il completamento dell'operazione.

tipo_di_valore

Tipo di valore della array_view e della matrice associata.

typedef typenamevalue_type value_type;

view_as

Reinterpreta questo array_view come un array_view di diverso rango.

template <
    int _New_rank
>
array_view<value_type,_New_rank> view_as(
    const Concurrency::extent<_New_rank>& _View_extent) const restrict(amp,cpu);

template <
    int _New_rank
>
array_view<const value_type,_New_rank> view_as(
    const Concurrency::extent<_New_rank> _View_extent) const restrict(amp,cpu);

Parametri

_New_rank
Classificazione del nuovo array_view oggetto.

_View_extent
Il rimodellamento extent.

value_type
Tipo di dati degli elementi nell'oggetto array originale e nell'oggetto restituito.

Valore restituito

Oggetto array_view costruito.

Vedi anche

Namespace Concurrency (C++ AMP)