clase ara::core::PolymorphicAllocator

La función miembro allocate de la clase ara::core::PolymorphicAllocator sirve para solicitar síncronamente memoria no inicializada para n objetos del tipo Tp [SWS_CORE_06547]. Se basa en la funcionalidad de [mem.poly.allocator.class], pero se desvía deliberadamente del estándar C++ mediante la declaración como noexcept y el atributo [[nodiscard]] [SWS_CORE_06547].

En caso de error, allocate no lanza ninguna excepción como std::bad_alloc, sino que devuelve en su lugar un nullptr [SWS_CORE_06547]. Debido a [[nodiscard]], el llamante debe recibir explícitamente el valor de retorno y comprobar si es nullptr antes de utilizar la región de memoria [SWS_CORE_06547]. En cuanto a la concurrencia, la función está clasificada como segura frente a excepciones, pero se considera no segura para subprocesos (not thread-safe) [SWS_CORE_06547]. Interpretación: por tanto, es probable que una llamada síncrona a través del mismo asignador desde distintos subprocesos requiera protección externa por parte del llamante. Pregunta Q-b00116faadf930fe (abierta)

El comportamiento tolerante a fallos sin excepciones se corresponde directamente con la interfaz ara::core::MemoryResource::allocate [SWS_CORE_06503], que también está definida como noexcept y devuelve nullptr en caso de error. Las instancias predefinidas como NullMemoryResource [SWS_CORE_06563] también emplean este principio y devuelven sistemáticamente nullptr en las llamadas de asignación. En un nivel superior, este mecanismo interactúa con contenedores como ara::core::Vector [SWS_CORE_01315], cuyos operadores de asignación están adaptados a tales propiedades de asignación.

usar

La función miembro allocate_bytes de la clase ara::core::PolymorphicAllocator reserva memoria bruta con un tamaño de nbytes y la alineación predeterminada alignment [SWS_CORE_06549]. El valor predeterminado para la alineación corresponde a alignof(std::max_align_t) [SWS_CORE_06549]. La función se incluye a través del encabezado ara/core/memory_resource.h y se ejecuta de forma síncrona [SWS_CORE_06549].

Tratamiento de errores y semántica

A diferencia del comportamiento estándar según [mem.poly.allocator.class], la implementación presenta dos desviaciones [SWS_CORE_06549]:

• La función está declarada como noexcept y no lanza excepciones [SWS_CORE_06549].
• Si la asignación falla, la función devuelve nullptr en lugar de lanzar una excepción [SWS_CORE_06549].

Debido al atributo [[nodiscard]], el valor de retorno debe ser evaluado por el invocador, en particular mediante una comprobación de nullptr antes de acceder al área de memoria [SWS_CORE_06549].

Concurrencia y restricciones

Respecto a la seguridad para subprocesos, el método está especificado como not thread-safe [SWS_CORE_06549]. Por tanto, es probable que las llamadas paralelas sobre la misma instancia requieran una sincronización externa [SWS_CORE_06549]. Pregunta Q-85c74d55563cae38 (abierta) En lo relativo a la seguridad frente a excepciones, la operación se considera exception safe [SWS_CORE_06549].

usar

La función miembro de plantilla allocate_object forma parte de la clase ara::core::PolymorphicAllocator y se proporciona a través del archivo de cabecera #include "ara/core/memory_resource.h" [SWS_CORE_06551]. Asigna memoria de forma síncrona para n objetos del tipo T, donde el parámetro n toma por defecto el valor 1 [SWS_CORE_06551]. El atributo de compilador [[nodiscard]] obliga a los llamadores a no ignorar el puntero tipificado T* devuelto.

Manejo de errores

La especificación define dos desviaciones explícitas respecto al estándar [mem.poly.allocator.class] [SWS_CORE_06551]:

• Sin excepciones: la función está declarada como noexcept y especificada como segura frente a excepciones (exception safe) [SWS_CORE_06551].
• Puntero nulo en caso de fallo: si la asignación de memoria falla, no se lanza ninguna excepción, sino que se devuelve obligatoriamente nullptr [SWS_CORE_06551].

Por lo tanto, el llamador debe comprobar si el puntero devuelto es nullptr inmediatamente antes de seguir utilizándolo.

Concurrencia y restricciones

La operación está especificada como no segura para subprocesos (not thread-safe) [SWS_CORE_06551]. En caso de uso concurrente de la misma instancia del asignador, es probable que se requiera una sincronización externa para evitar carreras de datos. Además, la función reserva memoria pura (interpretación: la construcción de objetos en la memoria reservada corresponde a mecanismos posteriores). Pregunta Q-c41df2caaeb4c503 (abierta)

La función de plantilla construct de la clase ara::core::PolymorphicAllocator ([SWS_CORE_06555]) sirve para la creación síncrona de un objeto del tipo T en la dirección de memoria p pasada, reenviando los argumentos args.... Está definida a través de la cabecera ara/core/memory_resource.h y sigue esencialmente las especificaciones de [mem.poly.allocator.class].

Una desviación explícita respecto al estándar C++ concierne al tratamiento de excepciones: según [SWS_CORE_06555], la función está declarada condicionalmente como noexcept, en función de si se cumple std::is_nothrow_constructible<T, Args...>::value. De este modo, la especificación le asigna el atributo conditionally exception safe. Interpretación: siempre que T no sea construible sin excepciones, es probable que cualquier excepción del constructor se propague sin trabas al llamador, ya que no se definen códigos de error internos ni mecanismos de captura especiales. Pregunta Q-ad77510f396e59ae (abierta)

En cuanto a concurrencia y condiciones de contorno, construct está especificada como no segura para subprocesos (not thread-safe) ([SWS_CORE_06555]). Por lo tanto, en accesos paralelos a la misma instancia de Allocator o a la misma área de memoria, se requiere obligatoriamente una sincronización externa en el contexto de llamada.

El patrón arquitectónico de una declaración noexcept dependiente del tipo corresponde a las convenciones de ara::core, tal y como se emplean también, entre otros, en los constructores de ara::core::Result ([SWS_CORE_00725], [SWS_CORE_00726]).

usar

La función miembro deallocate de la clase ara::core::PolymorphicAllocator libera la memoria asignada previamente para n objetos del tipo Tp a partir de la dirección p [SWS_CORE_06548]. La declaración se realiza a través de la cabecera ara/core/memory_resource.h [SWS_CORE_06548]. La función sigue en principio la semántica del asignador estándar de C++ conforme a [mem.poly.allocator.class], pero presenta dos desviaciones específicas [SWS_CORE_06548].

Tratamiento de errores y seguridad frente a excepciones

Como desviación fundamental, la operación está declarada como noexcept y especificada como segura frente a excepciones (exception safe) [SWS_CORE_06548]. Si la liberación de memoria falla, los errores que se produzcan se ignoran silenciosamente (silently ignored), de modo que ni se lanzan excepciones ni se notifican códigos de error explícitos [SWS_CORE_06548].

Concurrencia e interacción

En cuanto al contexto de llamada, deallocate está clasificada como no segura para subprocesos (not thread-safe) [SWS_CORE_06548]. En el concepto de gestión de memoria, esta función se corresponde con el método deallocate de la clase base subyacente ara::core::MemoryResource [SWS_CORE_06504], para la cual se aplican las mismas desviaciones respecto a noexcept y al tratamiento silencioso de errores.

La función deallocate_bytes de la clase ara::core::PolymorphicAllocator sirve para liberar un área de memoria previamente asignada conforme a [SWS_CORE_06550]. Se proporciona a través del encabezado ara/core/memory_resource.h y se basa fundamentalmente en la semántica de [mem.poly.allocator.class].

La llamada se realiza de forma síncrona y espera los siguientes parámetros según [SWS_CORE_06550]:

• p: puntero (void*) al área de memoria que se va a liberar.
• nbytes: tamaño en bytes de la memoria que se va a liberar (std::size_t).
• alignment: alineación deseada (valor predeterminado alignof(std::max_align_t)).

En cuanto al comportamiento frente a fallos, la implementación presenta desviaciones específicas respecto al estándar: la función está declarada como noexcept y se considera segura frente a excepciones (exception safe). Si la liberación falla, los errores producidos se ignoran de forma silenciosa (silently ignored) según [SWS_CORE_06550]. No se lanzan excepciones ni se proporcionan valores de retorno.

En relación con la concurrencia y las restricciones, la función está especificada explícitamente como no segura para subprocesos (not thread-safe) [SWS_CORE_06550]. Por tanto, es probable que el acceso concurrente a la misma instancia del asignador sin sincronización externa provoque un comportamiento indefinido. Pregunta Q-33c80e3bb50ed64f (abierta)

La función de plantilla deallocate_object de la clase ara::core::PolymorphicAllocator sirve para liberar memoria de objetos previamente reservada [SWS_CORE_06552]. Se orienta en el uso estándar de C++ correspondiente según [mem.poly.allocator.class], aunque presenta desviaciones específicas [SWS_CORE_06552].

En lo relativo a parámetros y contexto de llamada, se aplican las siguientes propiedades [SWS_CORE_06552]:

• Firma: template <class T> void deallocate_object (T *p, std::size_t n=1) noexcept; [SWS_CORE_06552].
• Cabecera: la función está disponible a través de #include "ara/core/memory_resource.h" [SWS_CORE_06552].
• Valor de retorno: la operación no devuelve ningún valor de retorno (void) [SWS_CORE_06552].
• Comportamiento con punteros nulos: como desviación explícita, se especifica que la función surte efecto cuando se pasa nullptr o que admite punteros nulos («Function is nullptr») [SWS_CORE_06552].

En cuanto al tratamiento de errores, la función está declarada como noexcept y se considera segura frente a excepciones (exception safe) [SWS_CORE_06552]. Si una desasignación falla, los errores producidos se ignoran de forma silenciosa («errors will be silently ignored»), de modo que no se propaga ninguna excepción al exterior [SWS_CORE_06552].

Como restricción esencial, deallocate_object está clasificada como no segura para subprocesos (not thread-safe) [SWS_CORE_06552]. En caso de accesos paralelos a la misma instancia de Allocator desde múltiples subprocesos, las llamadas deben protegerse, por lo tanto, mediante mecanismos de sincronización externa.

La función miembro delete_object de la clase ara::core::PolymorphicAllocator sirve, según [SWS_CORE_06554], para la destrucción y liberación de un objeto del tipo T al que apunta el puntero p pasado. La función se proporciona a través del archivo de cabecera #include "ara/core/memory_resource.h" y sigue el comportamiento de [mem.poly.allocator.class] con desviaciones específicas.

En cuanto al contexto de llamada y a la semántica, se aplican las siguientes propiedades:

• Valor de retorno y excepciones: la función no posee valor de retorno (void). Es condicionalmente segura frente a excepciones (conditionally noexcept) con la especificación noexcept(std::is_nothrow_destructible<T>::value); por tanto, no lanza excepciones siempre que el destructor de T esté declarado como no lanzador [SWS_CORE_06554].
• Tratamiento de errores: si la operación falla, los errores producidos se ignoran de forma silenciosa (errors will be silently ignored) [SWS_CORE_06554]. Interpretación: en caso de error, los llamadores no reciben, por tanto, ningún mensaje de error, ningún código de error ni ninguna excepción. Pregunta Q-9393b0f68a055e4b (abierta)
• Seguridad para subprocesos: la operación está especificada como no segura para subprocesos (not thread-safe) [SWS_CORE_06554]. En caso de uso concurrente del mismo asignador a través de varios subprocesos, la sincronización recae sobre el llamador.

usar

La función miembro de plantilla destroy de la clase ara::core::PolymorphicAllocator ([SWS_CORE_06556]) sirve para destruir un objeto del tipo T al que apunta el puntero p. La función está declarada en la cabecera ara/core/memory_resource.h y sigue fundamentalmente el comportamiento estandarizado de [mem.poly.allocator.class] ([SWS_CORE_06556]). La llamada al método no proporciona valor de retorno y se ejecuta de forma síncrona en el contexto del subproceso llamador. Interpretación: en este caso, cabe suponer que p apunta a un objeto válido instanciado previamente. Pregunta Q-a4faf7034eb683dd (abierta)

Tratamiento de errores y seguridad frente a excepciones

En relación con el tratamiento de errores, la función está clasificada como condicionalmente segura frente a excepciones (conditionally exception safe) ([SWS_CORE_06556]). Como desviación específica respecto al requisito estándar [mem.poly.allocator.class], destroy está declarada condicionalmente con noexcept(std::is_nothrow_destructible<T>::value) ([SWS_CORE_06556]). Siempre que el destructor del tipo T pasado no lance excepciones, la ausencia de excepciones se aplica a toda la llamada; de lo contrario, pueden escapar excepciones resultantes del destructor.

Concurrencia y restricciones

En cuanto al comportamiento de concurrencia, destroy está especificada como no segura para subprocesos (not thread-safe) ([SWS_CORE_06556]). Si varios subprocesos acceden simultáneamente a la misma instancia de ara::core::PolymorphicAllocator o al objeto que se va a destruir, deben establecerse mecanismos de sincronización externa adecuados.

La función miembro de plantilla new_object de la clase ara::core::PolymorphicAllocator (definida en #include "ara/core/memory_resource.h") asigna memoria de forma síncrona y construye un objeto del tipo T con los argumentos de constructor pasados ctor_args [SWS_CORE_06553].

El uso está sujeto a las siguientes determinaciones y desviaciones respecto al estándar [mem.poly.allocator.class] [SWS_CORE_06553]:

• Llamada y valor de retorno: si la creación del objeto tiene éxito, se devuelve un puntero tipificado T* a la nueva instancia. El atributo [[nodiscard]] obliga a los llamadores a evaluar el valor de retorno.
• Tratamiento de errores: en caso de fallo, a diferencia de [mem.poly.allocator.class] no se desencadena ninguna excepción, sino que se devuelve nullptr. Por tanto, el llamador debe comprobar obligatoriamente si el puntero resultante es nullptr antes de acceder.
• Seguridad frente a excepciones: la función está especificada como condicionalmente segura frente a excepciones (conditionally exception safe). Es noexcept si y solo si la propia creación del objeto garantiza que no lanzará ninguna excepción (noexcept(std::is_nothrow_constructible<T, CtorArgs...>::value)).
• Concurrencia: la función está declarada como no segura para subprocesos (not thread-safe). Interpretación: ante el acceso simultáneo a la misma instancia de ara::core::PolymorphicAllocator, es probable que el llamador sea responsable de una sincronización externa adecuada. Pregunta Q-3d0ecfe34187c91e (abierta)

El método resource es una función miembro constante de la clase ara::core::PolymorphicAllocator del archivo de cabecera #include "ara/core/memory_resource.h" [SWS_CORE_06557]. Sirve, de acuerdo con la referencia de especificación a [mem.poly.allocator.class], para la obtención síncrona del recurso de memoria asignado [SWS_CORE_06557].

Uso y signatura

La firma de la función es MemoryResource * resource () const noexcept; [SWS_CORE_06557]. La llamada se realiza sin parámetros y de forma síncrona sobre una instancia de ara::core::PolymorphicAllocator. Como valor de retorno, la función proporciona un puntero del tipo MemoryResource* [SWS_CORE_06557]. Interpretación: es probable que el puntero devuelto apunte directamente al recurso de memoria concreto que utiliza el asignador para las operaciones de memoria. Pregunta Q-392683a38a4e490b (abierta)

Tratamiento de errores y concurrencia

• Seguridad frente a excepciones: la función está declarada como noexcept y clasificada como exception safe [SWS_CORE_06557]. No lanza excepciones y no hay definidos códigos de error específicos.
• Seguridad para subprocesos: la especificación designa el método explícitamente como thread-safe [SWS_CORE_06557]. Gracias a la calificación como const, el acceso de lectura concurrente a través de múltiples subprocesos es seguro.

Interacción

En el módulo core, resource proporciona la interfaz para consultar el MemoryResource encapsulado por ara::core::PolymorphicAllocator y acceder a sus operaciones [SWS_CORE_06557].

usar

La función miembro select_on_container_copy_construction pertenece al ámbito de la clase ara::core::PolymorphicAllocator y se declara a través del archivo de cabecera #include "ara/core/memory_resource.h" ([SWS_CORE_06573]). Se llama de forma síncrona para crear una nueva instancia de PolymorphicAllocator durante la construcción por copia de un contenedor ([SWS_CORE_06573]). El comportamiento funcional sigue la directriz [mem.poly.allocator.class] ([SWS_CORE_06573]). Interpretación: es probable que el asignador resultante esté construido por defecto y, por tanto, recurra al recurso de memoria predeterminado en lugar de copiar obligatoriamente el recurso de memoria del contenedor de origen. Pregunta Q-134ed967dc22e133 (abierta)

Tratamiento de errores y seguridad frente a excepciones

Una desviación fundamental respecto a la especificación general de C++ consiste en que la función en AUTOSAR está declarada explícitamente como noexcept ([SWS_CORE_06573]). La ejecución está definida como segura frente a excepciones (exception safe) ([SWS_CORE_06573]). No se prevén códigos de error específicos, valores de retorno para la indicación de errores ni notificaciones a DET o DEM para esta interfaz, ya que se garantiza que la llamada finaliza sin errores.

Concurrencia y restricciones

Según la especificación, la función está clasificada como not thread-safe ([SWS_CORE_06573]). Esto significa que las llamadas simultáneas sobre la misma instancia de PolymorphicAllocator desde múltiples subprocesos sin sincronización externa pueden dar lugar a carreras de datos. Antes de copiar un contenedor en entornos concurrentes, el usuario debe proteger el acceso al objeto asignador.