Share via

array_view-klasse

Vertegenwoordigt een N-dimensionale weergave van de gegevens die zijn opgeslagen in een andere container.

Syntaxis

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

Parameterwaarden

value_type
Het gegevenstype van de elementen in het array_view object.

_Rang
De rang van het array_view object.

Leden

Openbare constructors

Naam Description
array_view constructor Initialiseert een nieuw exemplaar van de array_view klasse. Er is geen standaardconstructor voor array<T,N>. Alle constructors kunnen alleen worden uitgevoerd op de CPU en kunnen niet worden uitgevoerd op een Direct3D-doel.
~array_view destructor Vernietigt het array_view object.

Openbare methoden

Naam Description
copy_to Kopieert de inhoud van het array_view object naar de opgegeven bestemming door aan te roepen copy(*this, dest).
gegevens Retourneert een aanwijzer naar de onbewerkte gegevens van de array_view.
gegevens_verwijderen Hiermee verwijdert u de huidige gegevens die onder deze weergave worden weergegeven.
get_extent Retourneert het gebiedsobject van het array_view-object.
get_ref Retourneert een verwijzing naar het geïndexeerde element.
get_source_accelerator_view Retourneert de accelerator_view waar de gegevensbron van array_view zich bevindt.
opfrissen Hiermee wordt het array_view object op de hoogte gebracht dat het afhankelijke geheugen buiten de array_view interface is gewijzigd. Met een aanroep van deze methode worden alle gegevens in de cache verouderd.
reinterpret_as Retourneert een eendimensionale matrix die alle elementen in het array_view object bevat.
afdeling Retourneert een subsectie van het array_view object dat zich op de opgegeven oorsprong bevindt en, optioneel, die de opgegeven mate heeft.
Synchroniseren Synchroniseert eventuele wijzigingen die zijn aangebracht in het array_view object terug naar de brongegevens.
synchronize_async Asynchroon synchroniseert alle wijzigingen die zijn aangebracht in het array_view object terug naar de brongegevens.
synchronize_to Synchroniseert eventuele wijzigingen in het array_view object met de opgegeven accelerator_view.
synchronize_to_async Asynchroon synchroniseert eventuele wijzigingen in het array_view object met de opgegeven accelerator_view.
view_as Produceert een array_view object van een andere rang met behulp van de gegevens van dit array_view object.

Openbare operators

Naam Description
operator() Retourneert de waarde van het element dat is opgegeven door de parameter of parameters.
operator [] Retourneert het element dat is opgegeven door de parameters.
operator= Hiermee kopieert u de inhoud van het opgegeven array_view object naar dit object.

Openbare constanten

Naam Description
rangconstante Slaat de positie van het array_view object op.

Gegevensleden

Naam Description
Omvang Hiermee wordt het extent object opgehaald dat de vorm van het array_view object definieert.
source_accelerator_view Hiermee haalt u de accelerator_view op waar de gegevensbron van array_view zich bevindt
value_type Het waardetype van de array_view en de afhankelijke matrix.

Opmerkingen

De array_view klasse vertegenwoordigt een weergave van de gegevens die zijn opgenomen in een matrixobject of een subsectie van een array object.

U hebt toegang tot het array_view object waar de brongegevens zich bevinden (lokaal) of op een andere accelerator of een coherent domein (op afstand). Wanneer u het object op afstand opent, worden weergaven gekopieerd en indien nodig in de cache opgeslagen. Behalve de effecten van automatische caching, hebben array_view-objecten een prestatieprofiel dat vergelijkbaar is met dat van array-objecten. Er is een klein prestatieverlies wanneer u via weergaven de gegevens opent.

Er zijn drie scenario's voor extern gebruik:

  • Een weergave van een systeemgeheugenaanwijzer wordt doorgegeven door middel van een parallel_for_each aanroep naar een accelerator en geopend op de accelerator.

  • Een weergave van een matrix die zich op een accelerator bevindt, wordt doorgegeven door middel van een aanroep naar een parallel_for_each andere accelerator en wordt daar geopend.

  • Een weergave van een matrix die zich op een accelerator bevindt, wordt geopend op de CPU.

In een van deze scenario's worden de weergaven waarnaar wordt verwezen, gekopieerd door de runtime naar de externe locatie en, indien gewijzigd door de aanroepen naar het array_view object, terug naar de lokale locatie. De runtime kan het proces van het terugkopiëren van wijzigingen optimaliseren, alleen gewijzigde elementen kopiëren of ook ongewijzigde delen kopiëren. Overlappende array_view objecten op één gegevensbron blijven niet gegarandeerd referentiële integriteit behouden op een externe locatie.

U moet alle multithreaded-toegang tot dezelfde gegevensbron synchroniseren.

De runtime biedt de volgende garanties met betrekking tot het opslaan in cache van gegevens in array_view objecten:

  • Alle goed gesynchroniseerde toegangen tot een array object en een array_view object daarop in programmavolgorde gehoorzamen aan een seriële gebeurt-voor-relatie.

  • Alle goed gesynchroniseerde toegangen tot overlappende array_view objecten op dezelfde accelerator op één array object worden via het array object gealiaseerd. Ze veroorzaken een totaal-voor-voor-relatie die gehoorzaamt aan de orde van het programma. Er is geen caching. Als de array_view objecten worden uitgevoerd op verschillende accelerators, is de volgorde van toegang niet gedefinieerd, waardoor een racevoorwaarde wordt gemaakt.

Wanneer u een array_view object maakt met behulp van een aanwijzer in het systeemgeheugen, moet u het weergaveobject array_view alleen wijzigen via de array_view aanwijzer. U kunt ook een van de refresh() objecten aanroepen array_view die zijn gekoppeld aan de systeempointer, als het onderliggende systeemgeheugen rechtstreeks wordt gewijzigd, in plaats van via het array_view object.

Met beide acties wordt het array_view object aangegeven dat het onderliggende systeemeigen geheugen wordt gewijzigd en dat kopieën die zich in een accelerator bevinden, verouderd zijn. Als u deze richtlijnen volgt, zijn de pointer-gebaseerde weergaven identiek aan die van data-parallelle arrays.

Overnamehiërarchie

_Array_view_shape

_Array_view_base

array_view

Requirements

Koptekst: amp.h

Naamruimte: Gelijktijdigheid

~array_view

Vernietigt het array_view object.

~array_view()restrict(amp,cpu);

array_view

Initialiseert een nieuw exemplaar van de array_view klasse.

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

Parameterwaarden

_Arr_type
Het elementtype van een C-stijlmatrix waaruit gegevens worden opgegeven.

_Container
Een sjabloonargument dat een lineaire container moet specificeren die data() en size() elementen ondersteunt.

_E0
Het belangrijkste onderdeel van de omvang van deze sectie.

_E1
Het op een na belangrijkste onderdeel van de omvang van deze sectie.

_E2
Het minst significante onderdeel van de omvang van deze sectie.

_Mate
De omvang in elke dimensie van deze array_view.

_Andere
Een object van het type array_view<T,N> waaruit de nieuwe array_viewmoet worden geïnitialiseerd.

_Grootte
De grootte van een C-stijlmatrix waaruit gegevens worden opgegeven.

_Src
Een aanwijzer naar de brongegevens die naar de nieuwe matrix worden gekopieerd.

kopiëren_naar

Kopieert de inhoud van het array_view object naar het opgegeven doelobject door aan te roepen copy(*this, dest).

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

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

Parameterwaarden

_Dest
Het object waarnaar moet worden gekopieerd.

gegevens

Retourneert een aanwijzer naar de onbewerkte gegevens van de array_view.

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

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

Retourwaarde

Een aanwijzer naar de onbewerkte gegevens van de array_view.

gegevens_verwijderen

Hiermee verwijdert u de huidige gegevens die onder deze weergave worden weergegeven. Dit is een optimalisatiehint voor de runtime die wordt gebruikt om te voorkomen dat de huidige inhoud van de weergave wordt gekopieerd naar een doel accelerator_view waarop deze wordt geopend en het gebruik ervan wordt aanbevolen als de bestaande inhoud niet nodig is. Deze methode is een no-op wanneer deze wordt gebruikt in een restrict(amp)-context

void discard_data() const restrict(cpu);

Omvang

Hiermee wordt het extent object opgehaald dat de vorm van het array_view object definieert.

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

get_extent

Retourneert het omvangsobject van het array_view object.

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

Retourwaarde

Het extent object van het array_view object

get_ref

Haal een verwijzing op naar het element dat is geïndexeerd door _Index. In tegenstelling tot de andere indexeringsoperators voor toegang tot de array_view op de CPU, synchroniseert deze methode de inhoud van dit array_view niet impliciet met de CPU. Nadat u de array_view op een externe locatie hebt geopend of een kopieerbewerking hebt uitgevoerd waarbij deze array_view gebruikers betrokken zijn, moet u de array_view expliciet synchroniseren met de CPU voordat u deze methode aanroept. Als u dit niet doet, resulteert dit in niet-gedefinieerd gedrag.

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

Parameterwaarden

_Index
De index.

Retourwaarde

Verwijzing naar het element dat is geïndexeerd door _Index

get_source_accelerator_view

Retourneert de accelerator_view waar de gegevensbron van de array_view zich bevindt. Als de array_view geen gegevensbron heeft, genereert deze API een runtime_exception

accelerator_view get_source_accelerator_view() const;

Retourwaarde

operator()

Retourneert de waarde van het element dat is opgegeven door de parameter of parameters.

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

Parameterwaarden

_Index
De locatie van het element.

_I0
De index in de eerste dimensie.

_I1
De index in de tweede dimensie.

_I2
De index in de derde dimensie.

Ik
De locatie van het element.

Retourwaarde

De waarde van het element dat is opgegeven door de parameter of parameters.

operator[]

Retourneert het element dat is opgegeven door de parameters.

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

Parameterwaarden

_Index
De index.

Ik
De index.

Retourwaarde

De waarde van het element bij de index of een array_view geprojecteerd op de meest significante dimensie.

operator=

Hiermee kopieert u de inhoud van het opgegeven array_view object naar dit object.

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

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

Parameterwaarden

_Andere
Het array_view object waaruit moet worden gekopieerd.

Retourwaarde

Een verwijzing naar dit array_view object.

rank

Slaat de positie van het array_view object op.

static const int rank = _Rank;

vernieuwen

Hiermee wordt het array_view object op de hoogte gebracht dat het afhankelijke geheugen buiten de array_view interface is gewijzigd. Met een aanroep van deze methode worden alle gegevens in de cache verouderd.

void refresh() const restrict(cpu);

reinterpret_as

Herinterpreteert de array_view via een eendimensionale array_view, die als optie een ander waardetype kan hebben dan de bron-array_view.

Syntaxis

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

Parameterwaarden

_Value_type2
Het gegevenstype van het nieuwe array_view object.

Retourwaarde

Een array_view object of een const-object array_view dat op dit array_viewis gebaseerd, waarbij het elementtype is geconverteerd van T naar _Value_type2en de rang is verlaagd van N naar 1.

Opmerkingen

Soms is het handig om een multidimensionale matrix weer te geven als een lineaire, eendimensionale matrix, die mogelijk een ander waardetype heeft dan de bronmatrix. U kunt dit op een array_view bereiken met behulp van deze methode.

Waarschuwing Het opnieuw interpreteren van een array_view-object met behulp van een ander waardetype is een mogelijk onveilige bewerking. Deze functionaliteit moet zorgvuldig worden gebruikt.

Hier is een voorbeeld:

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

Retourneert een subsectie van het array_view object dat zich op de opgegeven oorsprong bevindt en, optioneel, die de opgegeven mate heeft.

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

Parameterwaarden

_E0
Het belangrijkste onderdeel van de omvang van deze sectie.

_E1
Het op een na belangrijkste onderdeel van de omvang van deze sectie.

_E2
Het minst significante onderdeel van de omvang van deze sectie.

_Ext
Het extent-object dat de omvang van de sectie aangeeft. De oorsprong is 0.

_Idx
Het indexobject dat de locatie van de oorsprong aangeeft. De subsectie is het resterende deel van het gebied.

_I0
Het belangrijkste onderdeel van de oorsprong van deze sectie.

_I1
Het op een na belangrijkste onderdeel van de oorsprong van deze sectie.

_I2
Het minst significante onderdeel van de oorsprong van deze sectie.

_Rang
De rang van de sectie.

_Section_extent
Het extent-object dat de omvang van de sectie aangeeft.

_Section_origin
Het indexobject dat de locatie van de oorsprong aangeeft.

Retourwaarde

Een subsectie van het array_view object dat zich op de opgegeven oorsprong bevindt en eventueel met de opgegeven omvang. Wanneer alleen het index object is opgegeven, bevat de subsectie alle elementen in de bijbehorende mate met indexen die groter zijn dan de indexen van de elementen in het index object.

source_accelerator_view

Hiermee haalt u de bron accelerator_view waaraan deze array_view is gekoppeld.

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

synchroniseren

Synchroniseert eventuele wijzigingen die zijn aangebracht in het array_view object terug naar de brongegevens.

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

void synchronize() const restrict(cpu);

Parameterwaarden

_Toegangstype
De beoogde access_type op het doel accelerator_view. Deze parameter heeft een standaardwaarde van access_type_read.

synchronize_async

Asynchroon synchroniseert alle wijzigingen die zijn aangebracht in het array_view object terug naar de brongegevens.

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

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

Parameterwaarden

_Toegangstype
De beoogde access_type voor de doelgerichte accelerator_view. Deze parameter heeft een standaardwaarde van access_type_read.

Retourwaarde

Een toekomst waarop moet worden gewacht totdat de bewerking is voltooid.

synchroniseren naar

Synchroniseert eventuele wijzigingen in deze array_view met de opgegeven accelerator_view.

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

Parameterwaarden

_Accl_view
Het doel accelerator_view om mee te synchroniseren.

_Toegangs_type
De gewenste access_type op het doel accelerator_view. Deze parameter heeft een standaardwaarde van access_type_read.

synchronize_to_async

Het asynchroon synchroniseren van eventuele wijzigingen in deze array_view met de opgegeven accelerator_view.

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

Parameterwaarden

_Accl_view
Het doelobject "accelerator_view" om mee te synchroniseren.

_Toegangstype
De gewenste "access_type" op de doel-"accelerator_view". Deze parameter heeft een standaardwaarde van access_type_read.

Retourwaarde

Een toekomst waarop moet worden gewacht totdat de bewerking is voltooid.

value_type

Het waardetype van de array_view en de afhankelijke matrix.

typedef typenamevalue_type value_type;

bekijken_als

Herinterpreteert dit array_view als een array_view van een andere 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);

Parameterwaarden

_New_rank
De rang van het nieuwe array_view object.

_View_extent
De hervorming extent.

value_type
Het gegevenstype van de elementen in zowel het oorspronkelijke matrixobject als het geretourneerde array_view object.

Retourwaarde

Het array_view object dat is geconstrueerd.

Zie ook

Concurrency-naamruimte (C++ AMP)

  • Last updated on