Partager via

array_view, classe

  • Article

Représente une vue ndimensionnelle sur les données conservées dans un autre conteneur.

Syntaxe

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)>;

Paramètres

value_type
Type de données des éléments dans l’objet array_view .

_Rang
Rang de l’objet array_view .

Membres

Constructeurs publics

Nom Description
constructeur array_view Initialise une nouvelle instance de la classe array_view. Il n’existe aucun constructeur par défaut pour array<T,N>. Tous les constructeurs sont limités à s’exécuter uniquement sur l’UC et ne peuvent pas être exécutés sur une cible Direct3D.
~array_view Destructeur Détruit l’objet array_view .

Méthodes publiques

Nom Description
copy_to Copie le contenu de l’objet array_view vers la destination spécifiée en appelant copy(*this, dest).
data Retourne un pointeur vers les données brutes du array_view.
discard_data Ignore les données actuelles sous-jacentes à cette vue.
get_extent Renvoie l’objet d’extension de l’objet array_view.
get_ref Retourne une référence à l’élément indexé.
get_source_accelerator_view Retourne le accelerator_view où se trouve la source de array_view données.
refresh Avertit l’objet array_view que sa mémoire liée a été modifiée en dehors de l’interface array_view . Un appel à cette méthode restitue toutes les informations mises en cache obsolètes.
reinterpret_as Retourne un tableau unidimensionnel qui contient tous les éléments de l’objet array_view .
section Retourne une sous-section de l’objet array_view qui se trouve à l’origine spécifiée et, éventuellement, qui a l’étendue spécifiée.
synchronize Synchronise toutes les modifications apportées à l’objet array_view à ses données sources.
synchronize_async Synchronise de façon asynchrone toutes les modifications apportées à l’objet array_view à ses données sources.
synchronize_to Synchronise toutes les modifications apportées à l’objet array_view à l’accelerator_view spécifié.
synchronize_to_async Synchronise de façon asynchrone toutes les modifications apportées à l’objet array_view à l’accelerator_view spécifié.
view_as Produit un objet d’un array_view rang différent à l’aide des données de cet array_view objet.

Opérateurs publics

Nom Description
operator() Retourne la valeur de l’élément spécifié par le paramètre ou les paramètres.
operator[] Retourne l’élément spécifié par les paramètres.
operator= Copie le contenu de l’objet spécifié array_view dans celui-ci.

Constantes publiques

Nom Description
constante de classement Stocke le rang de l’objet array_view .

Données membres

Nom Description
extent Obtient l'objet extent qui définit la forme de l'objet array_view.
source_accelerator_view Obtient l’accelerator_view où se trouve la source de données du array_view
value_type Type valeur du array_view tableau lié et du tableau lié.

Notes

La array_view classe représente une vue des données contenues dans un objet tableau ou une sous-section d’un array objet.

Vous pouvez accéder à l’objet array_view où se trouvent les données sources (localement) ou sur un autre accélérateur ou un domaine de cohérence (à distance). Lorsque vous accédez à l’objet à distance, les vues sont copiées et mises en cache si nécessaire. À l’exception des effets de la mise en cache automatique, array_view les objets ont un profil de performances similaire à celui des array objets. Il existe une petite pénalité de performances lorsque vous accédez aux données via des vues.

Il existe trois scénarios d’utilisation à distance :

  • Une vue vers un pointeur de mémoire système est passée par le biais d’un appel parallel_for_each à un accélérateur et accessible sur l’accélérateur.

  • Une vue d’un tableau situé sur un accélérateur est passée au moyen d’un parallel_for_each appel à un autre accélérateur et y accède.

  • Une vue sur un tableau situé sur un accélérateur est accessible sur le processeur.

Dans l’un de ces scénarios, les vues référencées sont copiées par le runtime à l’emplacement distant et, si modifiées par les appels à l’objet array_view , sont copiées à l’emplacement local. Le runtime peut optimiser le processus de copie des modifications, copier uniquement des éléments modifiés ou copier des parties inchangées également. array_view Les objets qui se chevauchent sur une source de données ne sont pas garantis pour maintenir l’intégrité référentielle dans un emplacement distant.

Vous devez synchroniser tout accès multithread à la même source de données.

Le runtime garantit les garanties suivantes concernant la mise en cache des données dans array_view les objets :

  • Tous les accès bien synchronisés à un array objet et à un array_view objet sur celui-ci dans l’ordre du programme obéissent à une relation série-avant.

  • Tous les accès bien synchronisés aux objets qui se chevauchent array_view sur le même accélérateur sur un seul array objet sont alias par le biais de l’objet array . Ils induisent un total se produit avant relation qui obéit à l’ordre du programme. Il n’y a pas de mise en cache. Si les array_view objets s’exécutent sur différents accélérateurs, l’ordre d’accès n’est pas défini, créant une condition de concurrence.

Lorsque vous créez un objet à l’aide d’un array_view pointeur dans la mémoire système, vous devez modifier l’objet d’affichage array_view uniquement via le array_view pointeur. Vous devez également appeler refresh() l’un des array_view objets attachés au pointeur système, si la mémoire native sous-jacente est modifiée directement, au lieu de passer par l’objet array_view .

L’une ou l’autre action avertit l’objet array_view que la mémoire native sous-jacente est modifiée et que toutes les copies situées sur un accélérateur sont obsolètes. Si vous suivez ces instructions, les vues basées sur le pointeur sont identiques à celles fournies aux vues des tableaux parallèles de données.

Hiérarchie d'héritage

_Array_view_shape

_Array_view_base

array_view

Spécifications

En-tête : amp.h

Espace de noms : Concurrency

~array_view

Détruit l’objet array_view .

~array_view()restrict(amp,cpu);

array_view

Initialise une nouvelle instance de la 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);

Paramètres

_Arr_type
Type d’élément d’un tableau de style C à partir duquel les données sont fournies.

_Conteneur
Argument de modèle qui doit spécifier un conteneur linéaire qui prend en charge et size() des data() membres.

_E0
Composant le plus important de l’étendue de cette section.

_E1
Composant suivant à la plus importante de l’étendue de cette section.

_E2
Composant le moins significatif de l’étendue de cette section.

_Étendue
Étendue dans chaque dimension de ce array_view.

_Autre
Objet de type array_view<T,N> à partir duquel initialiser le nouveau array_view.

_Taille
Taille d’un tableau de style C à partir duquel les données sont fournies.

_Src
Pointeur vers les données sources qui seront copiées dans le nouveau tableau.

copy_to

Copie le contenu de l’objet array_view vers l’objet de destination spécifié en appelant copy(*this, dest).

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

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

Paramètres

_Dest
Objet cible de la copie.

données

Retourne un pointeur vers les données brutes du array_view.

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

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

Valeur de retour

Pointeur vers les données brutes du array_view.

discard_data

Ignore les données actuelles sous-jacentes à cette vue. Il s’agit d’un indicateur d’optimisation pour le runtime utilisé pour éviter de copier le contenu actuel de la vue vers une cible accelerator_view sur laquelle il est accessible, et son utilisation est recommandée si le contenu existant n’est pas nécessaire. Cette méthode est une opération sans opération lorsqu’elle est utilisée dans un contexte restrict(amp)

void discard_data() const restrict(cpu);

extent

Obtient l'objet extent qui définit la forme de l'objet array_view.

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

get_extent

Retourne l’objet d’extension de l’objet array_view .

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

Valeur de retour

Objet extent de l’objet array_view

get_ref

Obtenez une référence à l’élément indexé par _Index. Contrairement aux autres opérateurs d’indexation pour accéder aux array_view sur l’UC, cette méthode ne synchronise pas implicitement le contenu de cette array_view avec l’UC. Après avoir accédé au array_view sur un emplacement distant ou effectué une opération de copie impliquant cette array_view utilisateurs sont responsables de synchroniser explicitement les array_view avec l’UC avant d’appeler cette méthode. L’échec de cette opération entraîne un comportement non défini.

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

Paramètres

_Index
Index.

Valeur de retour

Référence à l’élément indexé par _Index

get_source_accelerator_view

Retourne le accelerator_view où se trouve la source de données du array_view. Si le array_view n’a pas de source de données, cette API lève une runtime_exception

accelerator_view get_source_accelerator_view() const;

Valeur de retour

operator()

Retourne la valeur de l’élément spécifié par le paramètre ou les paramètres.

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);

Paramètres

_Index
Emplacement de l’élément.

_I0
Index dans la première dimension.

_I1
Index dans la deuxième dimension.

_I2
Index dans la troisième dimension.

_I
Emplacement de l’élément.

Valeur de retour

Valeur de l’élément spécifié par le paramètre ou les paramètres.

operator[]

Retourne l’élément spécifié par les paramètres.

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);

Paramètres

_Index
Index.

_I
Index.

Valeur de retour

Valeur de l’élément à l’index ou projetée array_view sur la dimension la plus significative.

opérateur =

Copie le contenu de l’objet spécifié array_view dans celui-ci.

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

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

Paramètres

_Autre
Objet array_view à copier.

Valeur de retour

Référence à cet array_view objet.

rank

Stocke le rang de l’objet array_view .

static const int rank = _Rank;

actualiser

Avertit l’objet array_view que sa mémoire liée a été modifiée en dehors de l’interface array_view . Un appel à cette méthode restitue toutes les informations mises en cache obsolètes.

void refresh() const restrict(cpu);

reinterpret_as

Réinterpret le array_view par le biais d’un array_view unidimensionnel, qui peut avoir un type de valeur différent de celui de la array_view source.

Syntaxe

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);

Paramètres

_Value_type2
Type de données du nouvel array_view objet.

Valeur de retour

Objet array_view ou objet const array_view basé sur ce array_viewpoint , avec le type d’élément converti en T _Value_type2et le rang réduit de N à 1.

Notes

Parfois, il est pratique d’afficher un tableau multidimensionnel sous la forme d’un tableau linéaire unidimensionnel, qui peut avoir un type de valeur différent du tableau source. Vous pouvez effectuer cette opération à l’aide array_view de cette méthode.

L’avertissement Reinterpreting d’un objet array_view à l’aide d’un type valeur différent est une opération potentiellement dangereuse. Cette fonctionnalité doit être utilisée avec soin.

Voici un exemple :

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);

section

Retourne une sous-section de l’objet array_view qui se trouve à l’origine spécifiée et, éventuellement, qui a l’étendue spécifiée.

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);

Paramètres

_E0
Composant le plus important de l’étendue de cette section.

_E1
Composant suivant à la plus importante de l’étendue de cette section.

_E2
Composant le moins significatif de l’étendue de cette section.

_Poste
Objet d’extension qui spécifie l’étendue de la section. L’origine est 0.

_Idx
Objet d’index qui spécifie l’emplacement de l’origine. La sous-section correspond au reste de l’étendue.

_I0
Composant le plus significatif de l’origine de cette section.

_I1
Composant suivant à la plus importante de l’origine de cette section.

_I2
Composant le moins significatif de l’origine de cette section.

_Rang
Rang de la section.

_Section_extent
Objet d’extension qui spécifie l’étendue de la section.

_Section_origin
Objet d’index qui spécifie l’emplacement de l’origine.

Valeur de retour

Sous-section de l’objet array_view qui se trouve à l’origine spécifiée et, éventuellement, qui a l’étendue spécifiée. Lorsque seul l’objet index est spécifié, la sous-section contient tous les éléments de l’étendue associée qui ont des index supérieurs aux index des éléments de l’objet index .

source_accelerator_view

Obtient le accelerator_view source auquel cette array_view est associée.

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

synchronize

Synchronise toutes les modifications apportées à l’objet array_view à ses données sources.

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

void synchronize() const restrict(cpu);

Paramètres

_Access_type
La access_type prévue sur le accelerator_view cible. Ce paramètre a la valeur access_type_readpar défaut .

synchronize_async

Synchronise de façon asynchrone toutes les modifications apportées à l’objet array_view à ses données sources.

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

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

Paramètres

_Access_type
La access_type prévue sur le accelerator_view cible. Ce paramètre a la valeur access_type_readpar défaut .

Valeur de retour

Un avenir sur lequel attendre la fin de l’opération.

synchronize_to

Synchronise toutes les modifications apportées à cette array_view au accelerator_view spécifié.

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);

Paramètres

_Accl_view
La cible accelerator_view à synchroniser.

_Access_type
La access_type souhaitée sur le accelerator_view cible. Ce paramètre a une valeur par défaut de access_type_read.

synchronize_to_async

Synchronise de façon asynchrone toutes les modifications apportées à cette array_view au accelerator_view spécifié.

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);

Paramètres

_Accl_view
La cible accelerator_view à synchroniser.

_Access_type
La access_type souhaitée sur le accelerator_view cible. Ce paramètre a une valeur par défaut de access_type_read.

Valeur de retour

Un avenir sur lequel attendre la fin de l’opération.

value_type

Type valeur du array_view et du tableau lié.

typedef typenamevalue_type value_type;

view_as

Réinterprète cela array_view comme un array_view autre rang.

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);

Paramètres

_New_rank
Classement du nouvel array_view objet.

_View_extent
Le remodelage extent.

value_type
Type de données des éléments dans l’objet tableau d’origine et l’objet retournéarray_view.

Valeur de retour

Objet array_view construit.

Voir aussi

Concurrency, espace de noms (C++ AMP)