Compartir por

Clase array_view

Representa una vista N dimensional sobre los datos contenidos en otro contenedor.

Sintaxis

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

Parámetros

value_type
El tipo de datos de los elementos en el objeto array_view.

_Rank
La clasificación del objeto array_view.

Miembros

Constructores públicos

Nombre Descripción
array_view Constructor Inicializa una nueva instancia de la clase array_view. No hay ningún constructor por defecto para array<T,N>. Todos los constructores están restringidos a ejecutarse solo en la CPU y no se pueden ejecutar en un destino de Direct3D.
~array_view Destructor Destruye el array_view objeto.

Métodos públicos

Nombre Descripción
copy_to Copia el contenido del objeto array_view al destino especificado llamando a copy(*this, dest).
data Devuelve un puntero a los datos sin procesar del array_view.
descarte_datos Descarta los datos actuales subyacentes a esta vista.
get_extent Devuelve el objeto de extensión del objeto array_view.
get_ref Devuelve una referencia al elemento indexado.
get_source_accelerator_view Devuelve el accelerator_view donde se encuentra el origen de datos del array_view.
actualizar Notifica al objeto array_view que su memoria asociada ha sido modificada fuera de la interfaz array_view. Una llamada a este método hace que toda la información en caché quede obsoleta.
reinterpret_as Devuelve una matriz unidimensional que contiene todos los elementos del objeto array_view.
section Devuelve una subsección del objeto array_view que está en el origen especificado y que, opcionalmente, tiene la extensión especificada.
synchronize Sincroniza cualquier modificación realizada en el objeto array_view con sus datos de origen.
synchronize_async Sincroniza de nuevo asincrónicamente cualquier modificación realizada en el objeto array_view con sus datos de origen.
synchronize_to Sincroniza las modificaciones realizadas en el array_view objeto con el accelerator_view especificado.
synchronize_to_async Sincroniza asincrónicamente cualquier modificación realizada en el objeto array_view con el accelerator_view especificado.
view_as Genera un objeto de clasificación diferente utilizando los datos de este objeto.

Operadores públicos

Nombre Descripción
operator() Devuelve el valor del elemento especificado por el parámetro o los parámetros.
operator[] Devuelve el elemento especificado por los parámetros.
operator= Copia el contenido del objeto especificado en este.

Constantes públicas

Nombre Descripción
Constante de rango Almacena la clasificación del objeto array_view.

Miembros de datos

Nombre Descripción
alcance Obtiene el objeto extent que define la forma del objeto array_view.
source_accelerator_view Obtiene el acelerador_view donde se encuentra el origen de datos del array_view.
value_type El tipo de valor de array_view y la matriz acotada.

Comentarios

La clase array_view representa una vista de los datos contenidos en un objeto array o una subsección de un objeto array.

Puede acceder al objeto array_view donde se encuentran los datos de origen (localmente) o en un acelerador diferente o en un dominio de coherencia (remotamente). Cuando se accede al objeto de forma remota, las vistas se copian y se almacenan en caché según sea necesario. Excepto por los efectos del almacenamiento en caché automático, los objetos array_view tienen un perfil de rendimiento similar al de los objetos array. Hay una pequeña penalización de rendimiento cuando se accede a los datos a través de vistas.

Hay tres escenarios de uso remoto:

  • Una vista a un puntero de memoria del sistema se pasa mediante una llamada de parallel_for_each a un acelerador y se accede a éste en el acelerador.

  • Se pasa una vista a una matriz ubicada en un acelerador mediante una llamada de parallel_for_each a otro acelerador y se accede allí.

  • Se accede a una vista de una matriz situada en un acelerador desde la CPU.

En cualquiera de estos escenarios, el runtime copia las vistas a las que se hace referencia en la ubicación remota y, si se modifican mediante las llamadas al objeto array_view, se copian de nuevo en la ubicación local. El runtime podría optimizar el proceso de copiar nuevamente los cambios; podría copiar solo elementos modificados o también copiar partes sin cambios. No se garantiza que los objetos superpuestos array_view en una fuente de datos mantengan la integridad referencial en una ubicación remota.

Debe sincronizar cualquier acceso de multithreading al mismo origen de datos.

El runtime realiza las siguientes garantías relativas al almacenamiento en caché de datos en objetos array_view.

  • Todos los accesos bien sincronizados a un objeto array y un objeto array_view en él, en el orden del programa, obedecen una relación serial ocurre-antes.

  • Todos los accesos bien sincronizados a objetos superpuestos array_view en el mismo acelerador de un solo objeto array reciben un alias a través del objeto array. Inducen una relación total ocurre-antes a la que obedece el orden del programa. No hay almacenamiento en caché. Si los array_view objetos se ejecutan en distintos aceleradores, el orden de acceso no está definido, lo que crea una race condition.

Al crear un objeto array_view mediante un puntero en la memoria del sistema, debe cambiar el objeto array_view solo a través del puntero array_view. Alternativamente, debe llamar a refresh() en uno de los objetos array_view adjuntos al puntero del sistema, si la memoria nativa subyacente se cambia directamente, en lugar de a través del objeto array_view.

Cualquiera de las acciones notifica al objeto array_view que la memoria nativa subyacente se ha modificado y que las copias ubicadas en un acelerador están obsoletas. Si sigue estas directrices, las vistas basadas en puntero son idénticas a las proporcionadas a las vistas de matrices paralelas de datos.

Jerarquía de herencia

_Array_view_shape

_Array_view_base

array_view

Requisitos

Encabezado: amp.h

Espacio de nombres: Concurrencia

~array_view

Destruye el array_view objeto.

~array_view()restrict(amp,cpu);

array_view

Inicializa una nueva instancia de la clase 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);

Parámetros

_Arr_type
El tipo de elemento de una matriz de estilo C a partir de la cual se proporcionan los datos.

_Container
Un argumento de plantilla que debe especificar un contenedor lineal que admita los miembros data() y size().

_E0
El componente más significativo en relación con el alcance de esta sección.

_E1
El penúltimo componente más significativo del alcance de esta sección.

_E2
El componente menos significativo del alcance de esta sección.

_Extent
La extensión en cada dimensión de este array_view.

_Other
Un objeto de tipo array_view<T,N> a partir del cual se inicializará el nuevo array_view.

_Size
El tamaño de una matriz de estilo C a partir de la cual se proporcionan los datos.

_Src
Un puntero a los datos de origen que se copiarán en la nueva matriz.

copiar_a

Copia el contenido del objeto array_view en el objeto de destino especificado al llamar a copy(*this, dest).

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

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

Parámetros

_Dest
El objeto al que se copiará.

datos

Devuelve un puntero a los datos sin procesar del array_view.

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

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

Valor devuelto

Un puntero a los datos sin procesar del array_view.

descartar_datos

Descarta los datos actuales subyacentes a esta vista. Esta es una sugerencia de optimización para el tiempo de ejecución que se utiliza para evitar copiar el contenido actual de la vista a un accelerator_view de destino al que se accede, y se recomienda su uso si no se necesita el contenido existente. Este método no implica ninguna operación cuando se usa en un contexto restrict(amp)

void discard_data() const restrict(cpu);

alcance

Obtiene el objeto extent que define la forma del objeto array_view.

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

get_extent

Devuelve el objeto extent del objeto array_view.

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

Valor devuelto

El extent del array_view

get_ref

Obtenga una referencia al elemento indexado por _Index. A diferencia de los otros operadores de indexación para acceder al array_view en la CPU, este método no sincroniza implícitamente este contenido de array_view con la CPU. Después de acceder a array_view en una ubicación remota o realizar una operación de copia que implique a esta array_view, los usuarios son responsables de sincronizar explícitamente la array_view con la CPU antes de llamar a este método. Si no lo hacen, se produce un comportamiento indefinido.

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

Parámetros

_Index
El índice.

Valor devuelto

Una referencia al elemento indexado por _Index

obtener_vista_acelerador_fuente

Devuelve el accelerator_view donde se encuentra el origen de datos del array_view. Si la array_view no tiene un origen de datos, esta API produce una runtime_exception

accelerator_view get_source_accelerator_view() const;

Valor devuelto

operator()

Devuelve el valor del elemento especificado por el parámetro o los parámetros.

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

Parámetros

_Index
La ubicación del elemento.

_I0
El índice en la primera dimensión.

_I1
El índice en la segunda dimensión.

_I2
El índice en la tercera dimensión.

_I
La ubicación del elemento.

Valor devuelto

El valor del elemento que está especificado por el parámetro o los parámetros.

operator[]

Devuelve el elemento especificado por los parámetros.

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

Parámetros

_Index
El índice.

_I
El índice.

Valor devuelto

El valor del elemento en el índice o un array_view proyectado en la dimensión más significativa.

operador =

Copia el contenido del objeto array_view especificado en este.

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

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

Parámetros

_Other
El objeto array_view desde el que se va a copiar.

Valor devuelto

Una referencia a este objeto array_view.

clasificación

Almacena la clasificación del objeto array_view.

static const int rank = _Rank;

actualizar

Notifica al objeto array_view que su memoria asociada ha sido modificada fuera de la interfaz array_view. Una llamada a este método hace que toda la información en caché quede obsoleta.

void refresh() const restrict(cpu);

reinterpretar_como

Reinterpreta la array_view a través de una array_view unidimensional, que opcionalmente puede tener un tipo de valor diferente al de la array_view de origen.

Sintaxis

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

Parámetros

_Value_type2
El tipo de datos del nuevo objeto array_view.

Valor devuelto

Un array_view objeto o un objeto const array_view que se basa en este array_view, con el tipo de elemento convertido de T a _Value_type2, y el rango reducido de N a 1.

Comentarios

A veces resulta conveniente ver una matriz multidimensional como si fuera una matriz unidimensional lineal, que podría tener un tipo de valor diferente al de la matriz de origen. Puede lograrlo en un array_view mediante este método.

Precaución Reinterpretar un objeto de array_view mediante un tipo de valor diferente es una operación potencialmente insegura. Esta funcionalidad debe usarse con cuidado.

Este es un ejemplo:

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

sección

Devuelve una subsección del objeto array_view que está en el origen especificado y que, opcionalmente, tiene la extensión especificada.

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

Parámetros

_E0
El componente más significativo en relación con el alcance de esta sección.

_E1
El penúltimo componente más significativo del alcance de esta sección.

_E2
El componente menos significativo del alcance de esta sección.

_Ext
El objeto extent que especifica el alcance de la sección. El origen es 0.

_Idx
El objeto index que especifica la ubicación del origen. La subsección es el resto de la extensión.

_I0
El componente más significativo del origen de esta sección.

_I1
El componente penúltimo más significativo del origen de esta sección.

_I2
El componente menos significativo del origen de esta sección.

_Rank
Rango de la sección.

_Section_extent
El objeto de extensión que especifica los límites de la sección.

_Section_origin
El objeto index que especifica la ubicación del origen.

Valor devuelto

Una subsección del objeto array_view que se encuentra en el origen especificado y que, opcionalmente, tiene la extensión especificada. Cuando solo se especifica el objeto index, la subsección contiene todos los elementos en la extensión asociada que tengan índices mayores que los índices de los elementos en el objeto index.

vista_del_acelerador_de_origen

Obtiene la accelerator_view de origen a la que está asociada esta array_view.

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

sincronizar

Sincroniza cualquier modificación realizada en el objeto array_view con sus datos de origen.

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

void synchronize() const restrict(cpu);

Parámetros

_Tipo_de_acceso
El tipo de acceso previsto en el access_type de la vista del acelerador objetivo (target accelerator_view). Este parámetro tiene un valor predeterminado de access_type_read.

synchronize_async

Sincroniza de nuevo asincrónicamente cualquier modificación realizada en el objeto array_view con sus datos de origen.

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

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

Parámetros

_Tipo_de_acceso
El tipo de acceso previsto en el access_type de la vista del acelerador objetivo (target accelerator_view). Este parámetro tiene un valor predeterminado de access_type_read.

Valor devuelto

Un futuro durante el cual esperar a que se complete la operación.

sincronizar con

Sincroniza cualquier modificación realizada a esta array_view en la accelerator_view especificada.

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

Parámetros

_Accl_view
La accelerator_view de destino con la que se sincronizará.

_Tipo_de_acceso
El tipo de acceso deseado en la vista del acelerador de destino. Este parámetro tiene un valor predeterminado de access_type_read.

sincronizar_a_asíncrono (synchronize_to_async)

Sincroniza asincrónicamente cualquier modificación realizada a esta array_view en la accelerator_view especificada.

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

Parámetros

_Accl_view
La accelerator_view de destino con la que se sincronizará.

_Tipo_de_acceso
El tipo de acceso deseado en la vista de acelerador de destino. Este parámetro tiene un valor predeterminado de access_type_read.

Valor devuelto

Un futuro durante el cual esperar a que se complete la operación.

tipo_de_valor

El tipo de valor de la array_view y la matriz de límites.

typedef typenamevalue_type value_type;

ver_como

Reinterpreta esto array_view como un array_view de un rango distinto.

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

Parámetros

_New_rank
El rango del nuevo array_view objeto.

_View_extent
El remodelado extent.

value_type
El tipo de datos de los elementos en ambos el objeto array original y el objeto array_view devuelto.

Valor devuelto

El objeto array_view que se ha construido.

Consulte también

Espacio de nombres Concurrency (C++ AMP)

  • Last updated on