Gère des blocs de mémoire dans un tampon à croissance monotone avec allocation sans exception et libération groupée.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 993d3b66f0fcProvenanceQuestions ouvertes (2)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Gère des blocs de mémoire dans un tampon à croissance monotone avec allocation sans exception et libération groupée.
La classe ara::core::MonotonicBufferResource fournit une ressource mémoire spécialisée pour des allocations rapides et monotones à partir d'un tampon mémoire fixe ou via une ressource amont (upstream). La mémoire demandée est attribuée progressivement et n'est pas immédiatement libérée lors de désallocations individuelles, mais uniquement réinitialisée de manière groupée via release() ([SWS_CORE_06530]). Toutes les opérations sont déclarées entièrement sans exception, un manque de mémoire étant signalé par le renvoi de nullptr au lieu d'une exception ([SWS_CORE_06569]). Les instances ne sont pas copiables et nécessitent une synchronisation externe en cas d'accès parallèle depuis plusieurs threads.
Contexte
La classe ara::core::MonotonicBufferResource est une ressource mémoire concrète au sein du module core de l'AUTOSAR Adaptive Platform et hérite de la classe de base ara::core::MemoryResource. Elle adapte le concept de std::pmr::monotonic_buffer_resource issu de [mem.res.monotonic.buffer], bien connu de la norme C++, pour les applications véhiculaires déterministes et critiques pour la sécurité. Le rôle principal de la classe consiste à répondre aux requêtes d'allocation avec un coût de gestion minimal à partir d'une zone mémoire continue, en attribuant la mémoire de manière monotone.
Les composants appelants, les allocateurs polymorphiques et les conteneurs qui demandent des blocs de mémoire au moment de l'exécution agissent d'une part en tant que partenaires d'interaction. D'autre part, la classe interagit avec une ressource mémoire amont (upstream) optionnelle de niveau supérieur (MemoryResource). Cette ressource upstream peut être transmise via des constructeurs tels que [SWS_CORE_06521] et interrogée via la méthode d'accès upstream_resource() ([SWS_CORE_06531]).
Cycle de vie
L'initialisation de ara::core::MonotonicBufferResource peut être contrôlée via plusieurs constructeurs. Outre un constructeur par défaut sans paramètre ([SWS_CORE_06524]), des surcharges sont disponibles qui acceptent une ressource amont explicite ([SWS_CORE_06521]), définissent une taille de tampon initiale ([SWS_CORE_06525], [SWS_CORE_06522]) ou utilisent une zone de mémoire brute fournie de manière externe (void* buffer, std::size_t buffer_size) comme tampon initial ([SWS_CORE_06526], [SWS_CORE_06523]).
En ce qui concerne les relations de propriété, la classe est définie comme strictement non copiable : le constructeur de copie ([SWS_CORE_06527]) et l'opérateur d'assignation par copie ([SWS_CORE_06529]) sont supprimés (=delete). Contrairement à la norme ISO 14882, la classe AUTOSAR implémente cependant une sémantique de déplacement explicite via le constructeur de déplacement ([SWS_CORE_06576]) et l'opérateur d'assignation par déplacement ([SWS_CORE_06577]), qui sont chacun définis comme noexcept=default.
La destruction s’effectue via le destructeur ~MonotonicBufferResource() ([SWS_CORE_06528]). Une divergence majeure d’AUTOSAR par rapport au standard réside dans le fait que le destructeur n’est pas déclaré virtuel. La méthode release() ([SWS_CORE_06530]) permet de réinitialiser l’ensemble de la mémoire allouée avant la fin de la durée de vie de l’objet.
Un déroulement applicatif typique comprend la mise à disposition, l’allocation continue et la libération groupée :
Instanciation : l’application crée une instance, par exemple en spécifiant une taille de tampon et une ressource en amont ([SWS_CORE_06522]) ou un tampon fixe ([SWS_CORE_06526]).
Allocation : les demandes de mémoire sont traitées via la méthode protégée do_allocate(bytes, alignment) ([SWS_CORE_06569]). Si le tampon existant ne suffit pas, l’instance obtient un nouveau tampon auprès de la ressource en amont.
Désallocation : les appels à do_deallocate(p, bytes, alignment) ([SWS_CORE_06570]) ne réduisent pas individuellement le tampon ; le pointeur d’allocation interne avance de façon monotone.
Réinitialisation du tampon : avec release() ([SWS_CORE_06530]), tous les blocs de mémoire obtenus en amont sont libérés d’un coup, et le tampon est prêt pour de nouveaux cycles.
Comparaison de ressources :do_is_equal() ([SWS_CORE_06571]) permet de vérifier si deux ressources mémoire sont identiques.
La classe suit des directives strictes pour les systèmes embarqués sans exceptions : l’ensemble des fonctions membres, des constructeurs et des opérateurs sont déclarés noexcept et offrent une sécurité d’exception complète.
En cas d’erreur, le comportement s’écarte délibérément de la bibliothèque standard :
Échec d’allocation : si une demande ne peut pas être servie dans do_allocate() ([SWS_CORE_06569]), aucune exception std::bad_alloc n’est levée, mais un nullptr est renvoyé. Les appelants doivent impérativement vérifier la valeur de retour par rapport à nullptr.
Erreur lors de la désallocation : si une erreur devait survenir lors de la libération dans do_deallocate() ([SWS_CORE_06570]), celle-ci est silencieusement ignorée d’après la spécification.
Destruction via un pointeur de base : comme le destructeur ([SWS_CORE_06528]) n’est pas virtuel, une destruction via un pointeur vers la classe de base MemoryResource devrait conduire à un comportement indéfini (interprétation : la destruction doit s’effectuer via le type concret). Question Q-add18020b48f3131 (ouverte)
Ce guide a été généré par un système d'IA sur la base de la spécification AUTOSAR Adaptive 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
As per corresponding usage in [mem.res.monotonic.buffer] 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 : 601be17f5d68ProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La fonction membre protégée do_allocate de la classe ara::core::MonotonicBufferResource sert à l'allocation de zones mémoire selon [mem.res.monotonic.buffer][SWS_CORE_06569]. Elle implémente l'interface virtuelle pure do_allocate de la classe de base ara::core::MemoryResource[SWS_CORE_06566]. À titre d'interprétation, en raison de la visibilité protected, l'appel synchrone devrait principalement s'effectuer indirectement via les méthodes d'affectation publiques de la classe de base. Question Q-21b2da19c0fd7f8f (ouverte) La fonction accepte la taille demandée en octets ainsi que l'alignement souhaité (alignment).
Traitement des erreurs et sécurité vis-à-vis des exceptions
Contrairement au comportement standard de C++, la fonction ne lève pas d'exception std::bad_alloc en cas d'erreurs d'allocation, mais renvoie à la place un nullptr[SWS_CORE_06569]. Grâce à la déclaration avec noexcept, la méthode est spécifiée comme sûre vis-à-vis des exceptions [SWS_CORE_06569]. Les appelants doivent donc toujours vérifier le résultat par rapport à nullptr afin de détecter une mémoire insuffisante.
Concurrence et interaction
La méthode est spécifiée comme non thread-safe [SWS_CORE_06569]. Si des affectations sont déclenchées de manière concurrente depuis plusieurs threads, la synchronisation doit s'effectuer de manière externe par le site appelant. Cela correspond au comportement de ara::core::UnsynchronizedPoolResource::do_allocate[SWS_CORE_00058], tandis que ara::core::SynchronizedPoolResource::do_allocate est conçue pour être thread-safe pour les appels concurrents [SWS_CORE_00061].
Cette note d'utilisation a été générée automatiquement à partir de la spécification AUTOSAR R25-11.
As per corresponding usage in [mem.res.monotonic.buffer] 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 : e7d49ed79e7cProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La fonction membre do_deallocate de la classe ara::core::MonotonicBufferResource sert à la désallocation de zones mémoire selon [SWS_CORE_06570]. Elle est définie via le fichier d'en-tête #include "ara/core/memory_resource.h"[SWS_CORE_06570]. La fonction accepte un pointeur p vers la zone mémoire à libérer ainsi que les paramètres bytes et alignment (chacun de type std::size_t) et ne fournit aucune valeur de retour (void) [SWS_CORE_06570]. La sémantique suit la définition dans [mem.res.monotonic.buffer] avec des divergences spécifiques à AUTOSAR [SWS_CORE_06570].
Gestion des erreurs
La fonction est déclarée comme noexcept et garantit la sécurité vis-à-vis des exceptions (exception safe) [SWS_CORE_06570]. Si une erreur survient lors de l'exécution, elle est silencieusement ignorée (errors will be silently ignored) [SWS_CORE_06570]. Il n'existe ni valeurs de retour ni codes d'erreur spécifiques pour les messages d'erreur.
Concurrence et restrictions
Concernant la concurrence, do_deallocate est spécifiée comme non thread-safe (not thread-safe) [SWS_CORE_06570]. Un appel simultané depuis plusieurs threads sans synchronisation externe n'est pas autorisé. La méthode possède la visibilité protected et surcharge l'interface virtuelle pure de la classe de base ara::core::MemoryResource[SWS_CORE_06567]. Interprétation : les appels devraient être traités normalement via l'interface publique de désallocation de la classe de base. Question Q-6916292acaa8993b (ouverte)
Interaction
Alors que la classe de base ara::core::MemoryResource prescrit la méthode de désallocation avec une visibilité privée [SWS_CORE_06567], MonotonicBufferResource ainsi que les classes apparentées ara::core::SynchronizedPoolResource[SWS_CORE_00041] et ara::core::UnsynchronizedPoolResource[SWS_CORE_00059] l'implémentent comme protégée (protected) avec un traitement muet des erreurs. Contrairement à la ressource de pool synchronisée [SWS_CORE_00041], qui est thread-safe, MonotonicBufferResource exige, tout comme ara::core::UnsynchronizedPoolResource[SWS_CORE_00059], l'exclusion d'accès parallèles.
Cette note d'utilisation a été rédigée par une IA et repose sur les définitions de la spécification AUTOSAR Adaptive R25-11.
As per corresponding usage in [mem.res.monotonic.buffer] except for the following deviations: 1. The function is noexcept
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : fc4ade44f9c3Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La méthode protected do_is_equal de la classe ara::core::MonotonicBufferResource surcharge l'interface virtuelle pure de la classe de base ara::core::MemoryResource selon [SWS_CORE_06571]. Elle compare l'instance actuelle de manière synchrone avec une const MemoryResource &other transmise afin de vérifier l'égalité quant à la sémantique de gestion de la mémoire.
Utilisation et sémantique
L'appel s'effectue typiquement de manière indirecte via l'interface publique de MemoryResource. Selon [SWS_CORE_06571], le comportement s'aligne sur l'utilisation dans [mem.res.monotonic.buffer], mais présente la divergence explicite selon laquelle la fonction est déclarée comme noexcept. La valeur de retour est un bool qui indique si les deux ressources sont interchangeables ou identiques.
Gestion des erreurs et concurrence
Exception-Sicherheit : la fonction est spécifiée comme exception safe et ne lève aucune exception en raison de la signature noexcept selon [SWS_CORE_06571]. Il n'existe pas de codes d'erreur spécifiques ni de notifications DET/DEM.
Thread-Sicherheit : l'opération est classée comme thread-safe ([SWS_CORE_06571]) et peut être exécutée de manière concurrente.
Interaction
La fonction implémente le contrat virtuel de ara::core::MemoryResource ([SWS_CORE_06568]). Des implémentations similaires de la comparaison d'égalité se retrouvent également dans d'autres ressources mémoire telles que ara::core::SynchronizedPoolResource ([SWS_CORE_00042]) et ara::core::UnsynchronizedPoolResource ([SWS_CORE_00060]).
Ce texte a été généré par une IA sur la base de la spécification R25-11.
As per corresponding usage in [mem.res.monotonic.buffer] except for the following deviations: 1. The function is noexcept
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 082c843665ceProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction membre release() de la classe ara::core::MonotonicBufferResource ([SWS_CORE_06530]) sert à libérer la mémoire gérée par la ressource de tampon. L'appel s'effectue de manière synchrone, ne prend aucun paramètre et ne renvoie aucune valeur (void).
En ce qui concerne le traitement des erreurs, la fonction est déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) ([SWS_CORE_06530]). Il n'existe aucun code d'erreur spécifique et aucun message d'erreur n'est envoyé à des instances centrales de diagnostic ou de signalement.
Concernant la concurrence, release() est explicitement classé comme non thread-safe (not thread-safe) ([SWS_CORE_06530]). Tout accès concurrent à la même instance sans synchronisation externe n'est pas autorisé. Interprétation : du fait de la sémantique inspirée de [mem.res.monotonic.buffer], toutes les zones de mémoire précédemment fournies via cette ressource devraient devenir non valides lors de l'appel. Question Q-bd46bd9971926d95 (ouverte)
Dans l'interaction des ressources mémoire de #include "ara/core/memory_resource.h", la fonction diffère par son comportement en matière de concurrence de ara::core::SynchronizedPoolResource::release(), qui est thread-safe ([SWS_CORE_00037]), tandis qu'elle se comporte de façon analogue à ara::core::UnsynchronizedPoolResource::release(), qui n'est également pas thread-safe ([SWS_CORE_00065]).
Ce texte a été généré par une IA sur la base des exigences de spécification d'AUTOSAR R25-11.
As per corresponding usage in [mem.res.monotonic.buffer] except for the following deviations: 1. The function is noexcept
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 34a11a1fee7aProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction membre upstream_resource() de la classe ara::core::MonotonicBufferResource renvoie de manière synchrone un pointeur vers la ressource mémoire amont de type MemoryResource*[SWS_CORE_06531]. L'appel s'effectue via l'en-tête #include "ara/core/memory_resource.h" et ne prend aucun paramètre [SWS_CORE_06531]. Interprétation : la ressource mémoire renvoyée devrait servir de tampon amont si le tampon interne de l'instance n'est pas suffisant pour les allocations. Question Q-e01e234e281bc4c6 (ouverte)
Concernant le traitement des erreurs et la sécurité vis-à-vis des exceptions, la méthode est déclarée comme noexcept et entièrement sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_06531]. Aucun code d'erreur spécifique, objet d'erreur ou message de diagnostic tel que DET ou DEM n'est prévu dans la spécification pour ce simple appel getter [SWS_CORE_06531].
En matière de concurrence, la méthode est spécifiée comme const ainsi que thread-safe (thread-safe) [SWS_CORE_06531]. Le pointeur vers la ressource amont peut ainsi être interrogé en parallèle à partir de plusieurs threads sans synchronisation externe.
La sémantique fonctionnelle suit la définition donnée dans [mem.res.monotonic.buffer], mais présente la divergence normative selon laquelle la fonction est explicitement définie comme noexcept dans le standard AUTOSAR Adaptive [SWS_CORE_06531]. Les classes apparentées ara::core::SynchronizedPoolResource[SWS_CORE_00038] ainsi que ara::core::UnsynchronizedPoolResource[SWS_CORE_00056] utilisent également un modèle d'interface analogue pour la mise à disposition de la ressource amont.
Ce texte a été rédigé par une IA sur la base des données de spécification.
As per corresponding usage in [mem.res.monotonic.buffer] except for the following deviations: 1. The function is noexcept 2. The function is not virtual
gemini-3.8-flash-low· 2026-10-13 · Original allemand