classe ara::core::PolymorphicAllocator

La fonction membre allocate de la classe ara::core::PolymorphicAllocator sert à demander de manière synchrone de la mémoire non initialisée pour n objets du type Tp [SWS_CORE_06547]. Elle s'inspire de la fonctionnalité de [mem.poly.allocator.class], mais s'écarte délibérément du standard C++ par sa déclaration comme noexcept et l'attribut [[nodiscard]] [SWS_CORE_06547].

En cas d'erreur, allocate ne lève pas d'exception comme std::bad_alloc, mais renvoie à la place un nullptr [SWS_CORE_06547]. En raison de [[nodiscard]], l'appelant doit explicitement récupérer la valeur de retour et vérifier la présence de nullptr avant d'utiliser la zone mémoire [SWS_CORE_06547]. Concernant la concurrence, la fonction est classée comme Exception-Safe, mais n'est pas considérée comme thread-safe (not thread-safe) [SWS_CORE_06547]. Interprétation : un appel synchrone via le même allocateur depuis différents threads devrait donc nécessiter une sécurisation externe par l'appelant. Question Q-b00116faadf930fe (ouverte)

Le comportement tolérant aux pannes sans exceptions correspond directement à l'interface ara::core::MemoryResource::allocate [SWS_CORE_06503], qui est également définie comme noexcept et renvoie nullptr en cas d'erreur. Les instances prédéfinies comme NullMemoryResource [SWS_CORE_06563] utilisent également ce principe et renvoient systématiquement nullptr lors des appels d'allocation. À un niveau supérieur, ce mécanisme interagit avec des conteneurs comme ara::core::Vector [SWS_CORE_01315], dont les opérateurs d'affectation sont adaptés à de telles propriétés d'allocation.

Utilisation

La fonction membre allocate_bytes de la classe ara::core::PolymorphicAllocator réserve de la mémoire brute d'un volume de nbytes avec l'alignement alignment spécifié [SWS_CORE_06549]. La valeur par défaut pour l'alignement correspond à alignof(std::max_align_t) [SWS_CORE_06549]. La fonction est incluse via l'en-tête ara/core/memory_resource.h et exécutée de manière synchrone [SWS_CORE_06549].

Traitement des erreurs et sémantique

À la différence du comportement standard selon [mem.poly.allocator.class], l'implémentation présente deux écarts [SWS_CORE_06549] :

• La fonction est déclarée comme noexcept et ne lève aucune exception [SWS_CORE_06549].
• Si l'allocation échoue, la fonction retourne nullptr au lieu de lever une exception [SWS_CORE_06549].

En raison de l'attribut [[nodiscard]], la valeur de retour doit être évaluée par l'appelant, en particulier au moyen d'une vérification de nullptr avant d'accéder à la zone mémoire [SWS_CORE_06549].

Concurrence et restrictions

En matière de sécurité des threads, la méthode est spécifiée comme not thread-safe [SWS_CORE_06549]. Les appels concurrents sur la même instance nécessitent donc vraisemblablement une synchronisation externe [SWS_CORE_06549]. Question Q-85c74d55563cae38 (ouverte) Concernant la sécurité vis-à-vis des exceptions, l'opération est considérée comme exception safe [SWS_CORE_06549].

Utilisation

La fonction membre modèle allocate_object fait partie de la classe ara::core::PolymorphicAllocator et est fournie via le fichier d'en-tête #include "ara/core/memory_resource.h" [SWS_CORE_06551]. Elle alloue de manière synchrone de la mémoire pour n objets du type T, le paramètre n ayant par défaut la valeur 1 [SWS_CORE_06551]. L'attribut de compilateur [[nodiscard]] contraint les appelants à ne pas ignorer le pointeur typé T* retourné.

Gestion des erreurs

La spécification définit deux divergences explicites par rapport au standard [mem.poly.allocator.class] [SWS_CORE_06551] :

• Aucune exception : la fonction est déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_06551].
• Pointeur nul en cas d'erreur : si l'allocation mémoire échoue, aucune exception n'est levée, mais nullptr est impérativement retourné [SWS_CORE_06551].

L'appelant doit donc vérifier si le pointeur fourni est égal à nullptr immédiatement avant toute réutilisation.

Concurrence et restrictions

L'opération est spécifiée comme non sûre pour les threads (not thread-safe) [SWS_CORE_06551]. En cas d'utilisation concurrente de la même instance d'allocateur, une synchronisation externe devrait être requise pour éviter les courses aux données. De plus, la fonction réserve de la mémoire brute (interprétation : la construction d'objets dans la mémoire réservée incombe aux mécanismes situés en aval). Question Q-c41df2caaeb4c503 (ouverte)

La fonction modèle construct de la classe ara::core::PolymorphicAllocator ([SWS_CORE_06555]) sert à la création synchrone d'un objet du type T à l'adresse mémoire transmise p en transmettant les arguments args.... Elle est définie via l'en-tête ara/core/memory_resource.h et suit pour l'essentiel les exigences issues de [mem.poly.allocator.class].

Une divergence explicite par rapport au standard C++ concerne la gestion des exceptions : selon [SWS_CORE_06555], la fonction est déclarée conditionnellement comme noexcept, selon que std::is_nothrow_constructible<T, Args...>::value s'applique ou non. La spécification lui attribue ainsi la qualification de conditionally exception safe. Interprétation : dans la mesure où T ne peut pas être construit sans exception, d'éventuelles exceptions du constructeur devraient être propagées sans entrave à l'appelant, car aucun code d'erreur interne ni mécanisme de capture particulier n'est défini. Question Q-ad77510f396e59ae (ouverte)

En ce qui concerne la concurrence et les conditions aux limites, construct est spécifiée comme non sûre pour les threads (not thread-safe) ([SWS_CORE_06555]). Lors d'accès parallèles à la même instance d'Allocator ou à la même zone mémoire, une synchronisation externe dans le contexte d'appel est donc impérativement requise.

Le patron d'architecture d'une déclaration noexcept dépendant du type correspond aux conventions énoncées dans ara::core, telles qu'elles sont entre autres également appliquées aux constructeurs de ara::core::Result ([SWS_CORE_00725], [SWS_CORE_00726]).

Utilisation

La fonction membre deallocate de la classe ara::core::PolymorphicAllocator libère la mémoire précédemment allouée pour n objets du type Tp à partir de l'adresse p [SWS_CORE_06548]. La déclaration s'effectue via l'en-tête ara/core/memory_resource.h [SWS_CORE_06548]. La fonction suit fondamentalement la sémantique de l'allocateur C++ standard selon [mem.poly.allocator.class], mais présente deux divergences spécifiques [SWS_CORE_06548].

Gestion des erreurs et sécurité vis-à-vis des exceptions

Comme divergence essentielle, l'opération est déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_06548]. Si la libération de la mémoire échoue, les erreurs survenues sont silencieusement ignorées (silently ignored), de sorte qu'aucune exception n'est levée ni aucun code d'erreur explicite n'est renvoyé [SWS_CORE_06548].

Concurrence et interaction

Concernant le contexte d'appel, deallocate est classée comme non thread-safe (not thread-safe) [SWS_CORE_06548]. Dans le concept de gestion de la mémoire, cette fonction correspond à la méthode deallocate de la classe de base sous-jacente ara::core::MemoryResource [SWS_CORE_06504], pour laquelle s'appliquent les mêmes divergences relatives à noexcept et au traitement silencieux des erreurs.

La fonction deallocate_bytes de la classe ara::core::PolymorphicAllocator sert à libérer une zone mémoire préalablement allouée conformément à [SWS_CORE_06550]. Elle est fournie via l'en-tête ara/core/memory_resource.h et s'appuie fondamentalement sur la sémantique issue de [mem.poly.allocator.class].

L'appel s'effectue de manière synchrone et attend les paramètres suivants conformément à [SWS_CORE_06550] :

• p : Pointeur (void*) vers la zone mémoire à libérer.
• nbytes : Taille de la mémoire à libérer en octets (std::size_t).
• alignment : Alignement souhaité (valeur par défaut alignof(std::max_align_t)).

En ce qui concerne le comportement face aux erreurs, l'implémentation présente des divergences spécifiques par rapport au standard : la fonction est déclarée comme noexcept et est considérée comme sûre vis-à-vis des exceptions (exception safe). Si la libération échoue, les erreurs survenues sont ignorées silencieusement (silently ignored) selon [SWS_CORE_06550]. Aucune exception n'est levée et aucune valeur de retour n'est fournie.

En ce qui concerne la concurrence et les restrictions, la fonction est explicitement spécifiée comme non sûre pour les threads (not thread-safe) [SWS_CORE_06550]. Un accès concurrent à la même instance d'allocateur sans synchronisation externe devrait donc conduire à un comportement indéfini. Question Q-33c80e3bb50ed64f (ouverte)

La fonction modèle deallocate_object de la classe ara::core::PolymorphicAllocator sert à libérer la mémoire d'objets préalablement réservée [SWS_CORE_06552]. Elle s'inspire de l'usage standard C++ correspondant conformément à [mem.poly.allocator.class], mais présente des divergences spécifiques [SWS_CORE_06552].

En ce qui concerne les paramètres et le contexte d'appel, les propriétés suivantes s'appliquent [SWS_CORE_06552] :

• Signature : template <class T> void deallocate_object (T *p, std::size_t n=1) noexcept; [SWS_CORE_06552].
• En-tête : la fonction est disponible via #include "ara/core/memory_resource.h" [SWS_CORE_06552].
• Valeur de retour : l'opération ne fournit aucune valeur de retour (void) [SWS_CORE_06552].
• Comportement vis-à-vis du pointeur nul : il est spécifié en tant que divergence explicite que la fonction s'applique lors du passage de nullptr ou prend en charge les pointeurs nuls (« Function is nullptr ») [SWS_CORE_06552].

Concernant le traitement des erreurs, la fonction est déclarée comme noexcept et est considérée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_06552]. Si une désallocation échoue, les erreurs survenues sont ignorées silencieusement (« errors will be silently ignored »), de sorte qu'aucune exception n'est propagée vers l'extérieur [SWS_CORE_06552].

En tant que restriction majeure, deallocate_object est classée comme non sûre pour les threads (not thread-safe) [SWS_CORE_06552]. Lors d'accès simultanés à la même instance d'Allocator depuis plusieurs threads, les appels doivent donc être sécurisés par des mécanismes de synchronisation externes.

La fonction membre delete_object de la classe ara::core::PolymorphicAllocator sert, conformément à [SWS_CORE_06554], à détruire et libérer un objet de type T référencé par le pointeur p transmis. La fonction est fournie via le fichier d'en-tête #include "ara/core/memory_resource.h" et suit le comportement de [mem.poly.allocator.class] avec des divergences spécifiques.

En ce qui concerne le contexte d'appel et la sémantique, les propriétés suivantes s'appliquent :

• Valeur de retour et exceptions : la fonction ne possède aucune valeur de retour (void). Elle est conditionnellement sûre vis-à-vis des exceptions (conditionally noexcept) avec la spécification noexcept(std::is_nothrow_destructible<T>::value), et ne lève donc aucune exception dans la mesure où le destructeur de T est déclaré comme ne levant pas d'exception [SWS_CORE_06554].
• Traitement des erreurs : si l'opération échoue, les erreurs survenues sont ignorées silencieusement (errors will be silently ignored) [SWS_CORE_06554]. Interprétation : les appelants ne reçoivent ainsi en cas d'erreur aucun message d'erreur, ni code d'erreur, ni exception. Question Q-9393b0f68a055e4b (ouverte)
• Sécurité des threads : l'opération est spécifiée comme non sûre pour les threads (not thread-safe) [SWS_CORE_06554]. En cas d'utilisation concurrente du même allocateur à travers plusieurs threads, la synchronisation incombe à l'appelant.

Utilisation

La fonction membre modèle destroy de la classe ara::core::PolymorphicAllocator ([SWS_CORE_06556]) sert à détruire un objet du type T référencé par le pointeur p. La fonction est déclarée dans l'en-tête ara/core/memory_resource.h et suit fondamentalement le comportement standardisé issu de [mem.poly.allocator.class] ([SWS_CORE_06556]). L'appel de méthode ne fournit aucune valeur de retour et est exécuté de manière synchrone dans le contexte du thread appelant. Interprétation : il devrait être supposé ici que p pointe vers un objet valide, préalablement instancié. Question Q-a4faf7034eb683dd (ouverte)

Gestion des erreurs et sécurité vis-à-vis des exceptions

Concernant le traitement des erreurs, la fonction est classée comme conditionnellement sûre vis-à-vis des exceptions (conditionally exception safe) ([SWS_CORE_06556]). En tant que divergence spécifique par rapport à l'exigence standard [mem.poly.allocator.class], destroy est déclarée conditionnellement avec noexcept(std::is_nothrow_destructible<T>::value) ([SWS_CORE_06556]). Dans la mesure où le destructeur du type transmis T ne lève aucune exception, l'absence d'exception s'applique à l'ensemble de l'appel ; dans le cas contraire, les exceptions résultant du destructeur peuvent s'échapper.

Concurrence et restrictions

En ce qui concerne le comportement en matière de concurrence, destroy est spécifiée comme non sûre pour les threads (not thread-safe) ([SWS_CORE_06556]). Si plusieurs threads accèdent simultanément à la même instance de ara::core::PolymorphicAllocator ou à l'objet à détruire, des mécanismes de synchronisation externes appropriés doivent être mis en place.

La fonction membre modèle new_object de la classe ara::core::PolymorphicAllocator (définie dans #include "ara/core/memory_resource.h") alloue de la mémoire de manière synchrone et construit un objet du type T avec les arguments de constructeur ctor_args transmis [SWS_CORE_06553].

L'utilisation est soumise aux dispositions et divergences suivantes par rapport au standard [mem.poly.allocator.class] [SWS_CORE_06553] :

• Appel et valeur de retour : en cas de création réussie de l'objet, un pointeur typé T* vers la nouvelle instance est retourné. L'attribut [[nodiscard]] oblige les appelants à évaluer la valeur de retour.
• Traitement des erreurs : en cas d'échec, contrairement à [mem.poly.allocator.class], aucune exception n'est levée, mais nullptr est retourné. L'appelant doit donc impérativement vérifier le pointeur résultant par rapport à nullptr avant tout accès.
• Sécurité vis-à-vis des exceptions : la fonction est spécifiée comme conditionnellement sûre vis-à-vis des exceptions (conditionally exception safe). Elle est noexcept si et seulement si la création de l'objet elle-même garantit qu'aucune exception n'est levée (noexcept(std::is_nothrow_constructible<T, CtorArgs...>::value)).
• Concurrence : la fonction est déclarée comme non sûre pour les threads (not thread-safe). Interprétation : en cas d'accès simultané à la même instance de ara::core::PolymorphicAllocator, l'appelant devrait être responsable d'une synchronisation externe appropriée. Question Q-3d0ecfe34187c91e (ouverte)

La méthode resource est une fonction membre constante de la classe ara::core::PolymorphicAllocator issue du fichier d'en-tête #include "ara/core/memory_resource.h" [SWS_CORE_06557]. Conformément à la référence de spécification vers [mem.poly.allocator.class], elle sert à récupérer de manière synchrone la ressource mémoire associée [SWS_CORE_06557].

Utilisation et signature

La signature de la fonction est MemoryResource * resource () const noexcept; [SWS_CORE_06557]. L'appel s'effectue sans paramètre et de manière synchrone sur une instance de ara::core::PolymorphicAllocator. En tant que valeur de retour, la fonction fournit un pointeur de type MemoryResource* [SWS_CORE_06557]. Interprétation : le pointeur retourné devrait pointer directement vers la ressource mémoire concrète que l'allocateur utilise pour les opérations mémoire. Question Q-392683a38a4e490b (ouverte)

Gestion des erreurs et concurrence

• Sécurité vis-à-vis des exceptions : la fonction est déclarée comme noexcept et classée comme exception safe [SWS_CORE_06557]. Elle ne lève aucune exception et aucun code d'erreur spécifique n'est défini.
• Sécurité des threads : la spécification désigne explicitement la méthode comme thread-safe [SWS_CORE_06557]. Grâce à la qualification comme const, l'accès en lecture concurrent à travers plusieurs threads est sûr.

Interaction

Dans le module core, resource fournit l'interface permettant d'interroger la MemoryResource encapsulée par ara::core::PolymorphicAllocator et de faire appel à ses opérations [SWS_CORE_06557].

Utilisation

La fonction membre select_on_container_copy_construction appartient à la portée de la classe ara::core::PolymorphicAllocator et est déclarée via le fichier d'en-tête #include "ara/core/memory_resource.h" ([SWS_CORE_06573]). Elle est appelée de manière synchrone afin de créer une nouvelle instance de PolymorphicAllocator lors de la construction par copie d'un conteneur ([SWS_CORE_06573]). Le comportement fonctionnel suit ici l'exigence [mem.poly.allocator.class] ([SWS_CORE_06573]). Interprétation : l'allocateur résultant devrait être construit par défaut et faire ainsi appel à la ressource mémoire par défaut, au lieu de copier obligatoirement la ressource mémoire du conteneur source. Question Q-134ed967dc22e133 (ouverte)

Gestion des erreurs et sécurité vis-à-vis des exceptions

Une divergence centrale par rapport à la spécification C++ générale réside dans le fait que la fonction est explicitement déclarée comme noexcept dans AUTOSAR ([SWS_CORE_06573]). L'exécution est définie comme sûre vis-à-vis des exceptions (exception safe) ([SWS_CORE_06573]). Aucun code d'erreur spécifique, aucune valeur de retour pour l'indication d'erreur ni aucune notification envoyée à DET ou DEM ne sont prévus pour cette interface, étant donné que l'appel termine avec la garantie d'être sans erreur.

Concurrence et restrictions

Selon la spécification, la fonction est classée comme not thread-safe ([SWS_CORE_06573]). Cela signifie que des appels simultanés sur la même instance PolymorphicAllocator depuis plusieurs threads sans synchronisation externe peuvent conduire à des courses aux données (data races). Avant de copier un conteneur dans des environnements concurrents, l'accès à l'objet allocateur doit être protégé par l'utilisateur.