Classe array

Artigo
08/04/2024

Representa um contêiner de dados usado para mover dados para um acelerador.

Sintaxe

template <typename value_type, int _Rank>
friend class array;

Parâmetros

value_type
O tipo de elemento dos dados.

_Rank
A classificação da matriz.

Membros

Construtores públicos

Nome	Descrição
Construtor array	Inicializa uma nova instância da classe `array`.
Destruidor ~array	Destrói o objeto `array`.

Métodos públicos

Nome	Descrição
copy_to	Copia o conteúdo da matriz para outra matriz.
data	Retorna um ponteiro para os dados brutos da matriz.
get_accelerator_view	Retorna o objeto accelerator_view que representa o local onde a matriz é alocada. Essa propriedade só pode ser acessada na CPU.
get_associated_accelerator_view	Obtém o segundo objeto accelerator_view que é passado como um parâmetro quando um construtor de preparo é chamado para instanciar o objeto `array`.
get_cpu_access_type	Retorna o access_type da matriz. Esse método só pode ser acessado na CPU.
get_extent	Retorna o objeto extent da matriz.
reinterpret_as	Retorna uma matriz unidimensional que contém todos os elementos no objeto `array`.
section	Retorna uma subseção do objeto `array` que está na origem especificada e, opcionalmente, que tem a extensão especificada.
view_as	Retorna um objeto array_view que é construído a partir do objeto `array`.

Operadores públicos

Nome	Descrição
`operator std::vector<value_type>`	Usa `copy(*this, vector)` para converter implicitamente a matriz em um objeto std::vector.
operador()	Retorna o valor do elemento especificado pelos parâmetros.
operador	Retorna o elemento que está no índice especificado.
operator=	Copia o conteúdo do objeto especificado `array` para este objeto.

Constantes públicas

Nome	Descrição
Constante rank	Armazena a classificação da matriz.

Membros de Dados Públicos

Nome	Descrição
accelerator_view	Obtém o objeto accelerator_view que representa o local onde a matriz é alocada. Essa propriedade só pode ser acessada na CPU.
associated_accelerator_view	Obtém o segundo objeto accelerator_view que é passado como um parâmetro quando um construtor de preparo é chamado para instanciar o objeto `array`.
cpu_access_type	Obtém o access_type que representa como a CPU pode acessar o armazenamento da matriz.
extent	Obtém a extensão que define a forma da matriz.

Comentários

O tipo array<T,N> representa uma matriz N dimensional densa e regular (não irregular) que está localizada em um local específico, como um acelerador ou a CPU. O tipo de dados dos elementos na matriz é T, que deve ser de um tipo compatível com o acelerador de destino. Embora a classificação, N, da matriz seja determinada estaticamente e faça parte do tipo, a extensão da matriz é determinada pelo runtime e é expressa usando a classe extent<N>.

Uma matriz pode ter qualquer número de dimensões, embora alguma funcionalidade seja especializada para objetos array com classificação um, dois e três. Se você omitir o argumento de dimensão, o padrão será 1.

Os dados da matriz são dispostos contiguamente na memória. Elementos que diferem por um na dimensão menos significativa são adjacentes na memória.

As matrizes são logicamente consideradas como tipos de valor, pois quando uma matriz é copiada para outra matriz, uma cópia profunda é executada. Duas matrizes nunca apontam para os mesmos dados.

O tipo array<T,N> é usado em vários cenários:

Como um contêiner de dados que pode ser usado em cálculos em um acelerador.
Como um contêiner de dados para manter a memória na CPU do host (que pode ser usada para copiar de e para outras matrizes).
Como um objeto de preparo para atuar como um intermediário rápido em cópias de host para dispositivo.

Hierarquia de herança

array

Requisitos

Cabeçalho: amp.h

Namespace: Simultaneidade

~array

Destrói o objeto array.

~array() restrict(cpu);

accelerator_view

Obtém o objeto accelerator_view que representa o local onde a matriz é alocada. Essa propriedade só pode ser acessada na CPU.

__declspec(property(get= get_accelerator_view)) Concurrency::accelerator_view accelerator_view;

matriz

Inicializa uma nova instância da classe de matriz. Não há construtor padrão para array<T,N>. Todos os construtores são executados somente na CPU. Eles não podem ser executados em um destino Direct3D.

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

explicit array(
    int _E0) restrict(cpu);

explicit array(
    int _E0,
    int _E1) restrict(cpu);

explicit array(
    int _E0,
    int _E1,
    int _E2) restrict(cpu);

array(
    const Concurrency::extent<_Rank>& _Extent,
    Concurrency::accelerator_view _Av
    access_type _Cpu_access_type = access_type_auto) restrict(cpu);

array(
    int _E0,
    Concurrency::accelerator_view _Av
    access_type _Cpu_access_type = access_type_auto) restrict(cpu);

array(
    int _E0,
    int _E1,
    Concurrency::accelerator_view _Av
    access_type _Cpu_access_type = access_type_auto) restrict(cpu);

array(
    int _E0,
    int _E1,
    int _E2,
    Concurrency::accelerator_view _Av
    access_type _Cpu_access_type = access_type_auto) restrict(cpu);

array(
    const Concurrency::extent<_Rank>& _Extent,
    Concurrency::accelerator_view _Av,
    Concurrency::accelerator_view _Associated_Av) restrict(cpu);

array(
    int _E0,
    accelerator_view _Av,
    Concurrency::accelerator_view _Associated_Av) restrict(cpu);

array(
    int _E0,
    int _E1,
    Concurrency::accelerator_view _Av,
    Concurrency::accelerator_view _Associated_Av) restrict(cpu);

array(
    int _E0,
    int _E1,
    int _E2,
    Concurrency::accelerator_view _Av,
    Concurrency::accelerator_view _Associated_Av) restrict(cpu);

template <typename _InputIterator>
array(
    const Concurrency::extent<_Rank>& _Extent,
    _InputIterator _Src_first,
    _InputIterator _Src_last) restrict(cpu);

template <typename _InputIterator>
array(
    const Concurrency::extent<_Rank>& _Extent,
    _InputIterator _Src_first) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    _InputIterator _Src_first,
    _InputIterator _Src_last) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    _InputIterator _Src_first) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    int _E1,
    _InputIterator _Src_first,
    _InputIterator _Src_last) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    int _E1,
    _InputIterator _Src_first) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    int _E1,
    int _E2,
    _InputIterator _Src_first,
    _InputIterator _Src_last) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    int _E1,
    int _E2,
    _InputIterator _Src_first) restrict(cpu);

template <typename _InputIterator>
array(
    const Concurrency::extent<_Rank>& _Extent,
    _InputIterator _Src_first,
    _InputIterator _Src_last,
    Concurrency::accelerator_view _Av
    access_type _Cpu_access_type = access_type_auto) restrict(cpu);

template <typename _InputIterator>
array(
    const Concurrency::extent<_Rank>& _Extent,
    _InputIterator _Src_first,
    Concurrency::accelerator_view _Av
    access_type _Cpu_access_type = access_type_auto) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    _InputIterator _Src_first,
    _InputIterator _Src_last,
    Concurrency::accelerator_view _Av
    access_type _Cpu_access_type = access_type_auto) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    _InputIterator _Src_first,
    Concurrency::accelerator_view _Av
    access_type _Cpu_access_type = access_type_auto) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    int _E1,
    _InputIterator _Src_first,
    _InputIterator _Src_last,
    Concurrency::accelerator_view _Av
    access_type _Cpu_access_type = access_type_auto) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    int _E1,
    _InputIterator _Src_first,
    Concurrency::accelerator_view _Av
    access_type _Cpu_access_type = access_type_auto) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    int _E1,
    int _E2,
    _InputIterator _Src_first,
    _InputIterator _Src_last,
    Concurrency::accelerator_view _Av,
    access_type _Cpu_access_type = access_type_auto) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    int _E1,
    int _E2,
    _InputIterator _Src_first,
    Concurrency::accelerator_view _Av
    access_type _Cpu_access_type = access_type_auto) restrict(cpu);

template <typename _InputIterator>
array(
    const Concurrency::extent<_Rank>& _Extent,
    _InputIterator _Src_first,
    _InputIterator _Src_last,
    Concurrency::accelerator_view _Av,
    Concurrency::accelerator_view _Associated_Av) restrict(cpu);

template <typename _InputIterator>
array(
    const Concurrency::extent<_Rank>& _Extent,
    _InputIterator _Src_first,
    Concurrency::accelerator_view _Av,
    Concurrency::accelerator_view _Associated_Av) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    _InputIterator _Src_first,
    _InputIterator _Src_last,
    Concurrency::accelerator_view _Av,
    Concurrency::accelerator_view _Associated_Av) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0, _InputIterator _Src_first,
    Concurrency::accelerator_view _Av,
    Concurrency::accelerator_view _Associated_Av) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    int _E1, _InputIterator _Src_first, _InputIterator _Src_last,
    Concurrency::accelerator_view _Av,
    Concurrency::accelerator_view _Associated_Av) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    int _E1, _InputIterator _Src_first,
    Concurrency::accelerator_view _Av,
    Concurrency::accelerator_view _Associated_Av) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    int _E1,
    int _E2, _InputIterator _Src_first, _InputIterator _Src_last,
    Concurrency::accelerator_view _Av,
    Concurrency::accelerator_view _Associated_Av) restrict(cpu);

template <typename _InputIterator>
array(
    int _E0,
    int _E1,
    int _E2, _InputIterator _Src_first,
    Concurrency::accelerator_view _Av,
    Concurrency::accelerator_view _Associated_Av) restrict(cpu);

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

array(
    const array_view<const value_type, _Rank>& _Src,
    accelerator_view _Av
    access_type _Cpu_access_type = access_type_auto) restrict(cpu);

array(
    const array_view<const value_type, _Rank>& _Src,
    accelerator_view _Av,
    accelerator_view _Associated_Av) restrict(cpu);

array(const array& _Other) restrict(cpu);

array(array&& _Other) restrict(cpu);

Parâmetros

_Associated_Av
Um accelerator_view que especifica o local de destino preferencial da matriz.

_Av
Um objeto accelerator_view que especifica o local da matriz.

_Cpu_access_type
O access_type desejado para a matriz na CPU. Esse parâmetro tem um valor padrão de access_type_auto deixando a determinação access_type de CPU para o runtime. O access_type de CPU real para a matriz pode ser consultado usando o método get_cpu_access_type.

_Extent
A extensão em cada dimensão da matriz.

_E0
O componente mais significativo da extensão desta seção.

_E1
O componente próximo ao mais significativo da extensão desta seção.

_E2
O componente menos significativo da extensão desta seção.

_InputIterator
O tipo do iterador de entrada.

_Src
Para o objeto a ser copiado.

_Src_first
Um iterador inicial no contêiner de origem.

_Src_last
Um iterador final no contêiner de origem.

_Other
Outra fonte de dados.

_Rank
A classificação da seção.

value_type
O tipo de dados dos elementos que são copiados.

associated_accelerator_view

Obtém o segundo objeto accelerator_view que é passado como um parâmetro quando um construtor de preparo é chamado para instanciar o objeto array.

__declspec(property(get= get_associated_accelerator_view)) Concurrency::accelerator_view associated_accelerator_view;

copy_to

Copia o conteúdo do array para outro array.

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

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

Parâmetros

_Dest
O objeto array_view para o qual copiar.

cpu_access_type

Obtém o access_type de CPU permitido para essa matriz.

__declspec(property(get= get_cpu_access_type)) access_type cpu_access_type;

data

Retorna um ponteiro para os dados brutos de array.

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

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

Valor de retorno

Um ponteiro para os dados brutos da matriz.

extent

Obtém o objeto de extensão que define a forma de array.

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

get_accelerator_view

Retorna o objeto accelerator_view que representa o local onde o objeto array é alocado. Essa propriedade só pode ser acessada na CPU.

Concurrency::accelerator_view get_accelerator_view() const;

Valor de retorno

O objeto accelerator_view que representa o local onde o objeto array é alocado.

get_associated_accelerator_view

Obtém o segundo objeto accelerator_view que é passado como um parâmetro quando um construtor de preparo é chamado para instanciar o objeto array.

Concurrency::accelerator_view get_associated_accelerator_view() const ;

Valor de retorno

O segundo objeto accelerator_view passado para o construtor de preparo.

get_cpu_access_type

Retorna o access_type de CPU permitido para essa matriz.

access_type get_cpu_access_type() const restrict(cpu);

Valor de retorno

get_extent

Retorna o objeto extent de array.

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

Valor de retorno

O objeto extent do objeto array.

`operator std::vector<value_type>`

Usa copy(*this, vector) para converter implicitamente a matriz em um objeto std::vector.

operator std::vector<value_type>() const restrict(cpu);

Parâmetros

value_type
O tipo de dados dos elementos do vetor.

Valor de retorno

Um objeto do tipo vector<T> que contém uma cópia dos dados contidos na matriz.

operador()

Retorna o valor do elemento especificado pelos parâmetros.

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

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

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

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

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

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

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

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

Parâmetros

_Index
O local do elemento.

_I0
O componente mais significativo da origem desta seção.

_I1
O componente próximo ao mais significativo da origem desta seção.

_I2
O componente menos significativo da origem desta seção.

_I
O local do elemento.

Valor de retorno

O valor do elemento especificado pelos parâmetros.

operador

Retorna o elemento que está no índice especificado.

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

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

typename details::_Projection_result_type<value_type,_Rank>::_Result_type operator[](int _i) restrict(amp,cpu);

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

Parâmetros

_Index
O índice .

_I
O índice .

Valor de retorno

O elemento que está no índice especificado.

operator=

Copia o conteúdo do objeto array especificado.

array& operator= (const array& _Other) restrict(cpu);

array& operator= (array&& _Other) restrict(cpu);

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

Parâmetros

_Other
O objeto array do qual copiar.

_Src
O objeto array do qual copiar.

Valor de retorno

Uma referência a esse objeto array.

rank

Armazena a classificação de array.

static const int rank = _Rank;

reinterpret_as

Reinterpreta a matriz por meio de um array_view unidimensional, que opcionalmente pode ter um tipo de valor diferente da matriz de origem.

Sintaxe

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

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

Parâmetros

_Value_type2
O tipo de dados referente aos dados retornados.

Valor de retorno

Um objeto array_view ou const array_view baseado na matriz, com o tipo de elemento reinterpretado de T para ElementType e a classificação reduzida de N para 1.

Comentários

Às vezes, é conveniente exibir uma matriz multidimensional como se fosse uma matriz linear unidimensional, possivelmente com um tipo de valor diferente da matriz de origem. Você pode usar esse método para conseguir isso. Cuidado Reinterpretar um objeto de matriz usando um tipo de valor diferente é uma operação potencialmente insegura. Recomendamos que você use essa funcionalidade com cuidado.

O código a seguir fornece um exemplo.

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

Retorna uma subseção do objeto array que está na origem especificada e, opcionalmente, que tem a extensão especificada.

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

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

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

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

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

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

array_view<value_type,1> section(
    int _I0,
    int _E0) restrict(amp,cpu);

array_view<const value_type,1> section(
    int _I0,
    int _E0) const restrict(amp,cpu);

array_view<value_type,2> section(
    int _I0,
    int _I1,
    int _E0,
    int _E1) restrict(amp,cpu);

array_view<const value_type,2> section(
    int _I0,
    int _I1,
    int _E0,
    int _E1) const restrict(amp,cpu);

array_view<value_type,3> section(
    int _I0,
    int _I1,
    int _I2,
    int _E0,
    int _E1,
    int _E2) restrict(amp,cpu);

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

Parâmetros

_E0
O componente mais significativo da extensão desta seção.

_E1
O componente próximo ao mais significativo da extensão desta seção.

_E2
O componente menos significativo da extensão desta seção.

_Ext
O objeto extent que especifica a extensão da seção. A origem é 0.

_Idx
O objeto de index que especifica o local da origem. A subseção é o restante da extensão.

_I0
O componente mais significativo da origem desta seção.

_I1
O componente próximo ao mais significativo da origem desta seção.

_I2
O componente menos significativo da origem desta seção.

_Rank
A classificação da seção.

_Section_extent
O objeto extent que especifica a extensão da seção.

_Section_origin
O objeto de index que especifica o local da origem.

value_type
O tipo de dados dos elementos que são copiados.

Valor de retorno

Retorna uma subseção do objeto array que está na origem especificada e, opcionalmente, que tem a extensão especificada. Quando apenas o objeto index é especificado, a subseção contém todos os elementos na grade associada que têm índices maiores que os índices dos elementos no objeto index.

view_as

Reinterpreta essa matriz como um array_view de uma classificação diferente.

template <int _New_rank>
array_view<value_type,_New_rank> view_as(
    const Concurrency::extent<_New_rank>& _View_extent) 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);

Parâmetros

_New_rank
A classificação do objeto extent passado como um parâmetro.

_View_extent
A extensão usada para construir o novo objeto array_view.

value_type
O tipo de dados dos elementos no objeto original array e no objeto retornado array_view.

Valor de retorno

O objeto array_view que é construído.

Confira também

Namespace de simultaneidade (C++ AMP)

Partilhar via

Classe array

Sintaxe

Parâmetros

Membros

Construtores públicos

Métodos públicos

Operadores públicos

Constantes públicas

Membros de Dados Públicos

Comentários

Hierarquia de herança

Requisitos

~array

accelerator_view

matriz

Parâmetros

associated_accelerator_view

copy_to

Parâmetros

cpu_access_type

data

Valor de retorno

extent

get_accelerator_view

Valor de retorno

get_associated_accelerator_view

Valor de retorno

get_cpu_access_type

Valor de retorno

get_extent

Valor de retorno

operator std::vector<value_type>

Parâmetros

Valor de retorno

operador()

Parâmetros

Valor de retorno

operador

Parâmetros

Valor de retorno

operator=

Parâmetros

Valor de retorno

rank

reinterpret_as

Sintaxe

Parâmetros

Valor de retorno

Comentários

section

Parâmetros

Valor de retorno

view_as

Parâmetros

Valor de retorno

Confira também

Comentários

Recursos adicionais

`operator std::vector<value_type>`