Sert d'interface de base pour l'allocation et la libération de mémoire sans exception.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : efd95fd8a941ProvenanceQuestions ouvertes (2)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Sert d'interface de base pour l'allocation et la libération de mémoire sans exception.
La classe fournit une interface de base abstraite pour les ressources de mémoire polymorphes, inspirée de l'interface standard C++. Par le biais du patron d'interface non virtuelle (Non-Virtual-Interface), elle délègue les requêtes d'allocation et de libération à des classes de ressources dérivées [SWS_CORE_06503]. Contrairement à la norme C++, toutes les fonctions d'interface sont déclarées sûres vis-à-vis des exceptions, raison pour laquelle les erreurs de mémoire ne sont pas signalées par une exception, mais par le retour d'un pointeur nul [SWS_CORE_06566]. De plus, les opérations d'allocation et de libération sont conçues par défaut comme non thread-safe.
Contexte
Dans l'AUTOSAR Adaptive Platform (module core), la classe ara::core::MemoryResource fournit une interface de base abstraite pour la gestion de la mémoire, inspirée du type standard C++ std::pmr::memory_resource. Elle sert de socle commun pour des stratégies d'allocation interchangeables et découple les structures de données appelantes des mécanismes concrets de mise à disposition de mémoire. Différence essentielle par rapport à la norme ISO C++, la spécification AUTOSAR renonce entièrement aux exceptions dynamiques et formule des garanties noexcept strictes pour l'ensemble des opérations [SWS_CORE_06501].
L'architecture suit le patron Non-Virtual Interface (NVI) : les fonctions membres publiques et non virtuelles définissent l'interface fixe pour les appelants, tandis que le comportement réel doit être implémenté dans les classes dérivées via des fonctions membres privées et purement virtuelles. Interprétation : les ressources mémoire concrètes dérivent de ara::core::MemoryResource et surchargent les interfaces de base privées do_allocate[SWS_CORE_06566], do_deallocate[SWS_CORE_06567] ainsi que do_is_equal[SWS_CORE_06568] afin de fournir des gestions de tampons ou de pools spécifiques à l'application. Question Q-d09d47b0a8f6b822 (ouverte)
Cycle de vie
L'instanciation des spécialisations s'effectue via le constructeur par défaut sans paramètre, spécifié comme noexcept=default[SWS_CORE_06501]. De même, un constructeur de copie noexcept [SWS_CORE_06502] et un opérateur d'affectation par copie noexcept [SWS_CORE_06507] sont disponibles. En complément de la norme C++, AUTOSAR définit explicitement un constructeur de déplacement [SWS_CORE_06574] et un opérateur d'affectation par déplacement [SWS_CORE_06575], tous deux définis comme noexcept=default.
Le cycle de vie des instances polymorphes est sécurisé par un destructeur virtuel déclaré sûr vis-à-vis des exceptions [SWS_CORE_06506]. En ce qui concerne la concurrence, il convient de noter que le destructeur ainsi que les fonctions d'allocation et de libération allocate[SWS_CORE_06503] et deallocate[SWS_CORE_06504] sont spécifiés comme non thread-safe. Interprétation : pour des allocations et libérations thread-safe, des mécanismes de synchronisation de niveau supérieur ou des sous-classes spécialisées devraient être compétents, car les méthodes de base sont spécifiées comme non thread-safe. Question Q-adac4b6cf6e0db7c (ouverte) Le test d'égalité via is_equal est en revanche explicitement conçu pour être thread-safe [SWS_CORE_06505].
Parcours d'utilisation
Le déroulement principal de la gestion de mémoire se compose de la demande, de la vérification facultative d'identité et de la libération ultérieure de blocs de mémoire via l'interface NVI publique :
Allocation de mémoire : l'appelant appelle allocate en indiquant la taille en octets et l'alignement facultatif [SWS_CORE_06503]. La méthode délègue en interne à la fonction privée purement virtuelle do_allocate de la classe concrète [SWS_CORE_06566].
Contrôle d'égalité : pour déterminer si deux ressources mémoire sont équivalentes l'une à l'autre et si la mémoire de l'une peut être libérée par l'autre, l'utilisateur appelle is_equal[SWS_CORE_06505], qui délègue à do_is_equal[SWS_CORE_06568].
Libération de mémoire : au terme de l'utilisation, le bloc est restitué via deallocate en indiquant le pointeur, la taille en octets et l'alignement [SWS_CORE_06504], ce qui déclenche le transfert interne à do_deallocate[SWS_CORE_06567].
Une caractéristique centrale de la classe est l'élimination totale des exceptions. Alors que la norme ISO C++ prévoit une exception de type std::bad_alloc en cas d'épuisement, AUTOSAR s'en écarte délibérément : si une allocation échoue dans allocate ou do_allocate, la fonction retourne obligatoirement nullptr[SWS_CORE_06503], [SWS_CORE_06566]. L'attribut [[nodiscard]] sur allocate incite l'appelant à toujours récupérer la valeur de retour et à vérifier sa validité avant tout accès.
Pour les opérations de libération deallocate et do_deallocate, les erreurs éventuelles lors de la restitution de la mémoire sont ignorées silencieusement [SWS_CORE_06504], [SWS_CORE_06567]. Aucune exception n'est levée et aucun code d'erreur n'est retourné, ce qui facilite le respect d'exigences strictes en matière de temps réel et de sécurité dans le contexte de la plateforme adaptative.
Ce texte a été élaboré par une IA et repose exclusivement sur les spécifications de l'AUTOSAR Adaptive Platform R25-11.
except for the following deviations: 1. The function is noexcept 2. The function returns nullptr instead of (potentially) throwing a std::bad_alloc exception ≙ std::bad_alloc
in [15] except for the following deviations: 1. The function is noexcept 2. The function returns nullptr instead of (potentially) throwing a std::bad_alloc exception ≙ std::bad_alloc
As per corresponding usage in [mem.res] except for the following deviations: 1. The function is noexcept 2. The function returns nullptr instead of (potentially) throwing a std::bad_alloc exception
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 6735dc6d085fProvenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction membre allocate de la classe ara::core::MemoryResource sert à l'allocation de mémoire linéaire avec une taille en octets et un alignement spécifiés [SWS_CORE_06503]. Elle s'inspire de l'interface standard C++ [mem.res], mais s'en écarte de manière significative en matière de traitement des exceptions [SWS_CORE_06503].
Utilisation et paramètres
L'appel s'effectue de manière synchrone via les paramètres bytes (nombre d'octets à demander) et le paramètre optionnel alignment, qui est défini par défaut sur alignof(std::max_align_t)[SWS_CORE_06503]. La valeur de retour est assortie de l'attribut [[nodiscard]], raison pour laquelle le pointeur de type void* fourni doit impérativement être évalué dans l'appelant [SWS_CORE_06503].
Gestion des erreurs et sécurité vis-à-vis des exceptions
Contrairement au comportement standard, la fonction ne lève aucune exception de type std::bad_alloc en cas d'erreur, mais est déclarée comme noexcept et est considérée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_06503] :
Succès : Fournit un pointeur valide vers la zone de mémoire allouée selon [mem.res][SWS_CORE_06503].
Échec : Si l'allocation de mémoire échoue, la fonction renvoie nullptr à la place [SWS_CORE_06503]. L'appelant doit donc toujours vérifier explicitement si le résultat est un pointeur nul.
Concurrence et interaction
La fonction est spécifiée comme non thread-safe (not thread-safe) [SWS_CORE_06503]. Les appels parallèles sur la même instance de MemoryResource nécessitent par conséquent une synchronisation externe par l'appelant. Ce modèle tolérant aux pannes et sans exception se retrouve de manière cohérente dans d'autres composants de mémoire d'AUTOSAR Adaptive : ainsi, ara::core::PolymorphicAllocator::allocate utilise la même approche sans exceptions [SWS_CORE_06547], et l'instance spécifique NullMemoryResource signale également l'épuisement de la mémoire en renvoyant nullptr[SWS_CORE_06563].
Cette note d'utilisation a été générée automatiquement sur la base de la spécification AUTOSAR R25-11.
As per corresponding usage in [mem.res] except for the following deviations: 1. The function is noexcept 2. If unsuccessful: errors will be silently ignored
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 65d739156bbeProvenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction deallocate de la classe ara::core::MemoryResource sert à la libération de zones de mémoire conformément à [SWS_CORE_06504]. L'utilisation suit fondamentalement le comportement standard de [mem.res], mais présente des divergences spécifiques. L'appel s'effectue de manière synchrone via la signature void deallocate(void *p, std::size_t bytes, std::size_t alignment=max_align) noexcept, où sont passés le pointeur p vers le bloc à libérer, la taille bytes ainsi qu'éventuellement l'alignement [SWS_CORE_06504].
En ce qui concerne le comportement face aux erreurs, la fonction est spécifiée comme noexcept et sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_06504]. Si la libération échoue, les erreurs sont ignorées silencieusement (errors will be silently ignored) [SWS_CORE_06504]. Aucune exception n'est levée et aucun message d'erreur n'est émis via DET ou DEM.
En matière de concurrence, la fonction est expressément classée comme non thread-safe (not thread-safe) [SWS_CORE_06504]. Les accès simultanés à la même instance de ressource doivent donc être synchronisés de manière externe par l'appelant.
Dans le cadre du concept d'allocateur, cette fonction correspond à l'interface typée deallocate de la classe ara::core::PolymorphicAllocator issue de [SWS_CORE_06548], qui présente des divergences similaires concernant noexcept et le traitement silencieux des erreurs.
Cette note d'utilisation a été générée automatiquement par un assistant de curation IA et se base exclusivement sur les données de spécification d'AUTOSAR R25-11.
As per corresponding usage in [mem.res] in [15] except for the following deviations: 1. The function is noexcept 2. The function returns nullptr instead of (potentially) throwing a std::bad_alloc exception
Literaturverzeichnis SWS Core: [15] ISO/IEC 14882:2020, Programming languages – C++ – www.iso.org
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : fa83e476b05dProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La méthode purement virtuelle do_allocate de la classe ara::core::MemoryResource sert à l'allocation de blocs de mémoire d'une taille en octets et d'un alignement prédéfinis [SWS_CORE_06566]. Elle prend en paramètres le nombre d'octets (bytes) ainsi que l'alignement requis (alignment). En cas d'allocation réussie, elle renvoie de manière synchrone un pointeur de type void * vers la zone mémoire réservée [SWS_CORE_06566].
En matière de traitement des erreurs, la fonction s'écarte délibérément du standard C++ standard : elle est déclarée comme noexcept et ne lève aucune exception std::bad_alloc en cas d'échec, mais renvoie à la place nullptr[SWS_CORE_06566]. Les appelants doivent donc toujours vérifier que le résultat de l'allocation n'est pas un pointeur nul.
Concernant la concurrence, la méthode est spécifiée comme not thread-safe[SWS_CORE_06566]. Les appels parallèles sur la même instance nécessitent une synchronisation externe, à moins que l'implémentation dérivée ne prévoie sa propre protection. En raison de la visibilité privée, l'appel par les utilisateurs devrait typiquement s'effectuer de manière indirecte via l'interface supérieure de la classe de base. Question Q-5cbdabf121ed4550 (ouverte)
Dans le cadre de la gestion de la mémoire, la méthode constitue le pendant direct de do_deallocate, qui est responsable de la libération de la mémoire allouée et ignore silencieusement les erreurs [SWS_CORE_06567]. La fonction de comparaison do_is_equal vérifie en outre si deux instances de ressource sont compatibles entre elles en ce qui concerne l'allocation et la libération [SWS_CORE_06568].
Cette note d'utilisation a été générée automatiquement sur la base de la spécification.
As per corresponding usage in [mem.res] except for the following deviations: 1. The function is noexcept 2. If unsuccessful: errors will be silently ignored
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : fca1a9bccecbProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction membre purement virtuelle do_deallocate de la classe ara::core::MemoryResource (déclarée dans ara/core/memory_resource.h) sert, conformément à [SWS_CORE_06567], à la libération de mémoire préalablement réservée. Elle reçoit le pointeur p vers la zone mémoire ainsi que sa taille bytes et l'alignement requis alignment. La sémantique correspond fondamentalement au standard C++ [mem.res], mais présente deux écarts majeurs propres à Adaptive [SWS_CORE_06567].
Premièrement, la fonction est déclarée comme noexcept et garantit la sécurité vis-à-vis des exceptions (exception safe) [SWS_CORE_06567]. Deuxièmement, les éventuelles erreurs survenues pendant la libération sont ignorées silencieusement, de sorte que les opérations ayant échoué ne doivent ni déclencher de messages d'erreur ni interrompre le flux d'exécution du programme [SWS_CORE_06567].
Concernant la concurrence, do_deallocate est spécifiée comme not thread-safe et possède une visibilité private[SWS_CORE_06567]. En tant que détail d'implémentation d'une ressource de mémoire polymorphe, elle devrait être exécutée de manière synchrone via l'interface d'appel publique de niveau supérieur. Question Q-3f97e122ee7fb281 (ouverte) Les libérations concurrentes sur la même ressource doivent être synchronisées de manière autonome par les classes dérivées si nécessaire.
Dans le module core, la fonction constitue le pendant de l'allocation do_allocate[SWS_CORE_06566], qui renvoie nullptr au lieu d'une exception en cas d'erreur. La comparaison avec d'autres ressources s'effectue via la méthode do_is_equal[SWS_CORE_06568], qui, contrairement à la désallocation, est explicitement définie comme thread-safe.
Cette note d'utilisation a été générée automatiquement sur la base de la spécification d'AUTOSAR R25-11.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : c0f1ba532a98ProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction membre purement virtuelle do_is_equal est déclarée dans l'en-tête #include "ara/core/memory_resource.h" au sein de l'espace de noms de ara::core::MemoryResource ([SWS_CORE_06568]). Elle sert, conformément à la spécification C++ [mem.res], à la comparaison synchrone d'égalité entre la ressource de mémoire courante et une référence transmise const MemoryResource &other ([SWS_CORE_06568]). La méthode étant définie avec une visibilité privée (private), son appel devrait être traité de manière polymorphe via l'interface publique de la classe ara::core::MemoryResource en tant que détail d'implémentation ([SWS_CORE_06568]). Question Q-cbe02f652b43d6ec (ouverte)
Concernant l'exécution et la tolérance aux erreurs, do_is_equal est déclarée comme exception safe ainsi que noexcept ([SWS_CORE_06568]). Elle ne doit donc lever aucune exception sous aucun prétexte et signale le résultat directement via la valeur de retour booléenne ([SWS_CORE_06568]). De plus, la méthode est spécifiée comme thread-safe, si bien que les implémentations dérivées doivent garantir la sécurité des threads y compris lors de comparaisons concurrentes ([SWS_CORE_06568]).
En association avec les autres méthodes virtuelles de gestion de la mémoire, do_is_equal complète le trio des points de personnalisation des classes de ressources dérivées ([SWS_CORE_06568]). Alors que l'allocation de mémoire do_allocate renvoie nullptr en cas d'erreur ([SWS_CORE_06566]) et que do_deallocate ignore silencieusement les erreurs ([SWS_CORE_06567]), les deux fonctions sont, contrairement à do_is_equal, désignées comme non thread-safe (not thread-safe) ([SWS_CORE_06566], [SWS_CORE_06567]). Cela souligne l'exigence particulière imposée à do_is_equal de sécuriser les comparaisons concurrentes de ressources ([SWS_CORE_06568]).
Ce texte a été généré par une IA et sert de note d'utilisation basée sur la spécification AUTOSAR.
gemini-3.8-flash-low· 2026-10-13 · Original allemand