Bietet eine threadsichere Pool-Speicherressource zur effizienten Zuteilung und Freigabe von Speicherblöcken.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 8c6c1308f3f6HerkunftOffene Fragen (3)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Bietet eine threadsichere Pool-Speicherressource zur effizienten Zuteilung und Freigabe von Speicherblöcken.
Die Klasse ara::core::SynchronizedPoolResource stellt eine threadsichere Speicherressource bereit, die Allokationen über interne Pools abwickelt und zusätzlichen Speicher von einer übergeordneten Upstream-Ressource anfordert ([SWS_CORE_00030]). Im Gegensatz zum C++-Standard wirft die Speicherallokation bei Fehlschlägen keine Ausnahmen, sondern liefert stattdessen nullptr zurück ([SWS_CORE_00061]). Kopieroperationen sind vollständig unterbunden, während Verschiebeoperationen explizit unterstützt werden. Zudem ist der Destruktor nicht virtuell, weshalb Instanzen nicht polymorph über einen Basisklassenzeiger freigegeben werden dürfen.
Kontext
Die Klasse ara::core::SynchronizedPoolResource stellt eine threadsichere Speicherressource für die AUTOSAR Adaptive Platform innerhalb des Moduls core bereit. Sie basiert auf dem Konzept von std::pmr::synchronized_pool_resource gemäß C++-Standard [mem.res.pool] und leitet öffentlich von der Basisklasse MemoryResource ab. Ihre Kernaufgabe besteht darin, Speicherblöcke über interne Pools nach Größenklassen zu verwalten, um wiederkehrende Zuteilungen effizient und nebenläufig abzuwickeln. Reicht der interne Vorrat nicht aus, bezieht die Instanz größere Speicherblöcke von einer übergeordneten Upstream-Speicherressource ([SWS_CORE_00038]).
Zu den typischen Interaktionspartnern zählen nebenläufige Threads einer Anwendung, die Zuteilungen anfordern, die SynchronizedPoolResource als vermittelnder Pool-Manager sowie eine zugrundeliegende MemoryResource als Upstream-Quelle. Alle zentralen Zugriffs- und Verwaltungsfunktionen wie do_allocate, do_deallocate, options und release sind threadsicher ausgelegt ([SWS_CORE_00061], [SWS_CORE_00041], [SWS_CORE_00039], [SWS_CORE_00037]).
Kontextdiagramm: Zusammenspiel von nebenläufigen Anwendungs-Threads, der Pool-Ressource und der Upstream-Speicherquelle. Quellen: [SWS_CORE_00030], [SWS_CORE_00038].
Lebenszyklus
Die Instanziierung von SynchronizedPoolResource kann über mehrere Konstruktorüberladungen erfolgen. Stehen sowohl Allokationsoptionen (PoolOptions) als auch eine Upstream-Ressource zur Verfügung, garantiert die Initialisierung vollständige Ausnahme-Sicherheit und ist als noexcept deklariert ([SWS_CORE_00030]). Daneben existieren Konstruktoren ohne Parameter ([SWS_CORE_00031]), mit alleinigem Upstream-Zeiger ([SWS_CORE_00032]) oder mit reinen Pool-Optionen ([SWS_CORE_00033]). Interpretation: Wird kein Upstream-Zeiger übergeben, greift die Implementierung vermutlich auf eine plattformspezifische Standard-Speicherressource zurück. Frage Q-5dafb414672249dc (offen)
In Bezug auf die Besitzverhältnisse schließt die Klasse ein Kopieren strikt aus: Sowohl der Kopierkonstruktor ([SWS_CORE_00034]) als auch der Kopierzuweisungsoperator ([SWS_CORE_00036]) sind gelöscht (=delete). Im Gegensatz zum ISO-C++17-Standard definiert AUTOSAR für diese Klasse jedoch explizit Verschiebesemantik: Ein Move-Konstruktor ([SWS_CORE_00043]) und ein Move-Zuweisungsoperator ([SWS_CORE_00044]) stehen jeweils als noexcept=default bereit.
Ein zentraler Aspekt der Zerstörung ist die Abweichung vom Standardverhalten: Der Destruktor ~SynchronizedPoolResource() ist explizit nicht virtuell ([SWS_CORE_00035]). Interpretation: Da der Destruktor nicht virtuell ist, dürfte eine polymorphe Zerstörung über einen Zeiger der Basisklasse MemoryResource* zu undefiniertem Verhalten führen; Instanzen sollten daher stets über ihren konkreten Typ abgebaut werden. Frage Q-5add73880279b024 (offen) Mit dem Aufruf von release() kann zudem der gesamte allozierte Speicher an die Upstream-Ressource zurückgegeben werden, während das Ressourcenobjekt intakt bleibt ([SWS_CORE_00037]).
Nutzungspfad
Der typische Ablauf umfasst die Initialisierung, die wiederholte Zuteilung und Freigabe von Speicherblöcken sowie die abschließende Bereinigung:
Initialisierung: Die Anwendung erzeugt die Instanz unter Angabe von Konfigurationsparametern und einer übergeordneten Speicherressource ([SWS_CORE_00030]). Die aktiven Einstellungen lassen sich über options() abfragen ([SWS_CORE_00039]), der Upstream-Zeiger über upstream_resource() ([SWS_CORE_00038]).
Speicherallokation: Speicheranforderungen werden geschützt über do_allocate abgearbeitet ([SWS_CORE_00061]). Interpretation: Der Aufruf im Anwendungscode erfolgt üblicherweise nicht direkt über die geschützte Methode do_allocate, sondern über die geerbte öffentliche Schnittstelle allocate der Basisklasse MemoryResource. Frage Q-1542a47cdff73dfb (offen)
Identitätsprüfung: Über do_is_equal kann ermittelt werden, ob zwei Speicherressourcen zueinander äquivalent sind ([SWS_CORE_00042]).
Freigabe: Einzelne Speicherbereiche werden über do_deallocate an den Pool zurückgeführt ([SWS_CORE_00041]). Bei Bedarf kann über release() sämtlicher Speicher aller Pools gebündelt an die Upstream-Ressource zurückgegeben werden ([SWS_CORE_00037]).
Die AUTOSAR Adaptive Platform weicht bei der Fehlerbehandlung gezielt von den Ausnahmekonventionen des C++-Standards ab:
Allokationsfehler: Während ISO-C++ im Erschöpfungsfall das Werfen von std::bad_alloc vorsieht, ist do_allocate in AUTOSAR als noexcept definiert. Kann kein passender Speicherblock bereitgestellt werden, gibt die Methode stattdessen zwingend einen Nullzeiger (nullptr) zurück ([SWS_CORE_00061]). Aufrufer müssen daher jeden Zuteilungsrückgabewert auf nullptr prüfen.
Deallokationsfehler: Die Methode do_deallocate ist ebenfalls noexcept. Tritt bei der Rückgabe eines Speicherblocks ein Fehler auf, wird dieser laut Spezifikation stillschweigend ignoriert ([SWS_CORE_00041]).
Konstruktionsrisiken: Während der Konstruktor mit Optionen und Upstream-Ressource ausnahmesicher ist ([SWS_CORE_00030]), sind die Konstruktoren ohne Upstream-Angabe oder ohne Optionen als nicht ausnahmesicher („not exception safe“) klassifiziert ([SWS_CORE_00031], [SWS_CORE_00032], [SWS_CORE_00033]). Interpretation: Schlägt bei diesen Konstruktoren die interne Bereitstellung von Pool-Verwaltungsstrukturen fehl, kann die Objekterzeugung scheitern. Frage (offen)
Dieser Klassen-Leitfaden fasst die Spezifikation von ara::core::SynchronizedPoolResource für AUTOSAR Adaptive Release R25-11 zusammen.
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.pool] except for the following deviations: 1. The function is noexcept 2. The function returns nullptr instead of (potentially) throwing a std::bad_alloc exception
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: d6b2e58cc49aHerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung und Allokationssemantik
Die Elementfunktion do_allocate der Klasse ara::core::SynchronizedPoolResource aus der Header-Datei #include "ara/core/memory_resource.h" dient der Allokation von Speicherbereichen mit der spezifizierten Bytegröße bytes und Ausrichtung alignment[SWS_CORE_00061]. Im Erfolgsfall liefert der synchrone Aufruf gemäß [mem.res.pool] einen gültigen Zeiger vom Typ void* auf den zugewiesenen Speicherblock zurück [SWS_CORE_00061].
Fehlerbehandlung und Abweichungen
Hinsichtlich des Fehlerverhaltens weicht die Implementierung explizit von den Vorgaben aus [mem.res.pool] ab: Die Methode ist als noexcept deklariert und löst keine std::bad_alloc-Exception aus [SWS_CORE_00061]. Bei einem Fehlschlag der Speicheranforderung ist der zurückgegebene Zeiger stattdessen zwingend nullptr[SWS_CORE_00061]. Aufrufer müssen den Rückgabewert daher zwingend auf einen Nullzeiger prüfen, um Allokationsfehler zuverlässig abzufangen.
Nebenläufigkeit und Zusammenspiel
Die Funktion ist als exception safe und im Gegensatz zu anderen Speicherressourcen als thread-safe spezifiziert [SWS_CORE_00061]. Aufgrund ihrer protected-Sichtbarkeit dürfte sie in der Praxis vor allem als interne Überschreibung der rein virtuellen Basisschnittstelle do_allocate aus ara::core::MemoryResource fungieren [SWS_CORE_06566]. Frage Q-95ba181693426bfc (offen) Während ara::core::SynchronizedPoolResource den nebenläufigen Zugriff absichert [SWS_CORE_00061], sind vergleichbare Implementierungen wie ara::core::UnsynchronizedPoolResource::do_allocate[SWS_CORE_00058] und ara::core::MonotonicBufferResource::do_allocate[SWS_CORE_06569] als not thread-safe definiert.
Dieser Text wurde durch ein KI-System auf Basis der Spezifikation AUTOSAR Adaptive R25-11 generiert.
As per corresponding usage in [mem.res.pool] except for the following deviations: 1. The function is noexcept 2. If unsuccessful: errors will be silently ignored
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: b07cac0de0a1HerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die geschützte Elementfunktion do_deallocate der Klasse ara::core::SynchronizedPoolResource dient der Freigabe eines zuvor allozierten Speicherbereichs gemäß [SWS_CORE_00041]. Ihr Aufruf erfolgt synchron und erwartet als Parameter einen Zeiger p auf den Speicherbereich, die Größe bytes in Bytes sowie das Speicher-Alignment alignment. Da die Elementfunktion mit Sichtbarkeit protected deklariert ist, wird sie im regulären Anwendungs-Code vermutlich nicht unmittelbar aufgerufen, sondern über die öffentliche Schnittstelle zur Deallokation der übergeordneten Basisklasse ara::core::MemoryResource ausgeführt ([SWS_CORE_06567]). Frage Q-badea921c907c214 (offen)
Hinsichtlich Fehlerbehandlung und Ausnahmeverhalten definiert die Spezifikation zwei verbindliche Abweichungen vom Standard:
Die Funktion ist als noexcept deklariert und vollständig ausnahmesicher (exception safe) ([SWS_CORE_00041]).
Sollte die Deallokation nicht erfolgreich sein, werden aufgetretene Fehler stillschweigend ignoriert ([SWS_CORE_00041]). Es erfolgt weder das Werfen einer Exception noch die Rückmeldung eines Fehlercodes.
Im Bereich der Nebenläufigkeit zeichnet sich die Implementierung in ara::core::SynchronizedPoolResource dadurch aus, dass sie explizit als threadsicher (thread-safe) spezifiziert ist ([SWS_CORE_00041]). Damit eignet sie sich für den gleichzeitigen Aufruf aus mehreren Threads. Hierin unterscheidet sie sich wesentlich von den verwandten Ressourcen ara::core::UnsynchronizedPoolResource ([SWS_CORE_00059]) und ara::core::MonotonicBufferResource ([SWS_CORE_06570]), die als nicht threadsicher klassifiziert sind.
Dieser Text wurde von einer KI auf Basis der Spezifikation AUTOSAR R25-11 generiert.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: c89ab0c97360HerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die geschützte Elementfunktion do_is_equal prüft die Gleichheit einer Instanz von ara::core::SynchronizedPoolResource mit einer anderen Speicherressource [SWS_CORE_00042]. Sie überschreibt die rein virtuelle Basisklassenmethode aus ara::core::MemoryResource[SWS_CORE_06568] gemäß der Spezifikation für Pool-Ressourcen in [mem.res.pool].
Verwendung und Schnittstelle: Als Parameter wird eine Referenz auf ein anderes ara::core::MemoryResource-Objekt übergeben (const MemoryResource &other). Der Rückgabewert vom Typ bool zeigt an, ob beide Ressourcen äquivalent sind. Interpretation: Aufgrund der Sichtbarkeit protected wird die Funktion im regulären Anwendungsablauf nicht unmittelbar aufgerufen, sondern über die öffentliche Vergleichsmethode der Basisklasse ausgeführt. Frage Q-29fb2980d1241fae (offen)
Fehlerbehandlung und Sicherheit: Die Methode ist mit dem Bezeichner noexcept deklariert und als exception safe spezifiziert [SWS_CORE_00042]. Es treten weder Exceptions noch spezifische Fehlercodes auf. Die Ausführung erfolgt synchron.
Nebenläufigkeit: Gemäß [SWS_CORE_00042] ist do_is_equal als thread-safe spezifiziert, sodass gleichzeitige Vergleiche über mehrere Threads hinweg ohne zusätzliche externe Synchronisation zulässig sind.
Zusammenspiel: Die Funktion bildet das threadsichere Gegenstück zur Implementierung in ara::core::UnsynchronizedPoolResource[SWS_CORE_00060]. Ebenso stellt ara::core::MonotonicBufferResource eine korrespondierende Überschreibung bereit, welche ebenfalls als noexcept gekennzeichnet ist [SWS_CORE_06571].
Dieser Text wurde von einer KI auf Basis der Spezifikation AUTOSAR Adaptive R25-11 generiert.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 4714ac548826HerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Elementfunktion options der Klasse ara::core::SynchronizedPoolResource liefert die für die Speicherressource konfigurierten Einstellungen vom Typ PoolOptions synchron zurück [SWS_CORE_00039]. Der Aufruf erfolgt parameterlos auf einer Instanz der Klasse und ist über den Header ara/core/memory_resource.h deklariert [SWS_CORE_00039]. Das Verhalten orientiert sich laut Spezifikation an [mem.res.pool][SWS_CORE_00039], was als Anlehnung an die Pool-Ressourcen des C++-Standards interpretiert werden dürfte. Frage Q-9abfddc2cf8dc88c (offen)
Hinsichtlich der Fehlerbehandlung und Ausnahmesicherheit ist die Methode als noexcept deklariert und gilt als vollständig ausnahmesicher (exception safe) [SWS_CORE_00039]. Spezifische Fehlercodes oder Meldungen an DET oder DEM existieren für diese Abfragefunktion nicht.
Bezüglich der Nebenläufigkeit ist die Methode als const sowie ausdrücklich als threadsicher (thread-safe) spezifiziert [SWS_CORE_00039]. Sie kann somit ohne zusätzliche Synchronisierungsmaßnahmen auf Anwenderebene sicher und parallel aus mehreren Threads aufgerufen werden.
Im Zusammenspiel innerhalb von ara::core stellt [SWS_CORE_00057] das un-synchronisierte Gegenstück bereit: Für ara::core::UnsynchronizedPoolResource existiert eine namens- und signaturgleiche Funktion options mit identischer Semantik gemäß [mem.res.pool].
Dieser Text wurde von einer KI generiert und dient als orientierende Nutzungshilfe.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 32c426df4959HerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die synchrone Elementfunktion release() gehört zur Klasse ara::core::SynchronizedPoolResource und wird über die Header-Datei #include "ara/core/memory_resource.h" bereitgestellt [SWS_CORE_00037]. Sie besitzt die Signatur void release () noexcept;, nimmt keine Parameter entgegen und besitzt keinen Rückgabewert. Die funktionale Semantik richtet sich nach der entsprechenden Verwendung in [mem.res.pool][SWS_CORE_00037], womit der durch die Speicherressource verwaltete Speicher freigegeben wird.
Hinsichtlich der Fehlerbehandlung ist die Funktion als ausnahmesicher (exception safe) und noexcept deklariert [SWS_CORE_00037]. Es treten keine C++-Exceptions auf; spezifische Fehlercodes oder Fehlerberichte über DET bzw. DEM werden im Spezifikationsumfang nicht definiert.
In Bezug auf die Nebenläufigkeit ist die Operation ausdrücklich als thread-sicher (thread-safe) spezifiziert [SWS_CORE_00037]. Ein gleichzeitiger Aufruf aus mehreren Threads auf derselben Ressourceninstanz dürfte daher ohne zusätzliche anwendungsseitige Sperren zulässig sein. Frage Q-3da3b45ca2070b3e (offen)
Im Zusammenspiel entspricht das Verhalten der funktionsgleichen Methode in ara::core::UnsynchronizedPoolResource[SWS_CORE_00065], die ebenfalls auf [mem.res.pool] verweist und als noexcept sowie thread-safe ausgewiesen ist. Im Gegensatz dazu ist die analoge release()-Funktion der ara::core::MonotonicBufferResource[SWS_CORE_06530] laut Spezifikation nicht thread-sicher (not thread-safe), obgleich sie ebenfalls der noexcept-Garantie unterliegt.
Dieser Text wurde von einer KI erstellt und basiert ausschließlich auf den Spezifikationsdaten von AUTOSAR R25-11.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 6f69b7b33ad7Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die Elementfunktion upstream_resource() der Klasse ara::core::SynchronizedPoolResource liefert einen Zeiger auf die zugrundeliegende vorgeschaltete Speicherressource (MemoryResource*) gemäß [SWS_CORE_00038]. Der Aufruf erfolgt synchron und erfordert das Einbinden der Header-Datei #include "ara/core/memory_resource.h"[SWS_CORE_00038]. Die Funktion nimmt keine Übergabeparameter entgegen und dient als reiner Inspektor für die übergeordnete Speicherverwaltungseinheit.
Fehlerbehandlung und Ausnahme-Sicherheit
Die Methode ist als noexcept deklariert und spezifikationsgemäß als ausnahmesicher (exception safe) eingestuft [SWS_CORE_00038]. Ein Scheitern der Abfrage oder das Auslösen von Ausnahmen ist ausgeschlossen; Fehlercodes existieren für diesen Aufruf nicht.
Nebenläufigkeit und Einschränkungen
Die Funktion ist als const sowie explizit als threadsicher (thread-safe) spezifiziert [SWS_CORE_00038]. Sie kann somit nebenläufig von mehreren Ausführungskontexten ohne zusätzliche externe Synchronisation aufgerufen werden.
Zusammenspiel
Das Konzept einer vorgelagerten Speicherressource wird konsistent über verschiedene Speicherpool-Implementierungen von AUTOSAR Adaptive Core hinweg bereitgestellt:
In ara::core::UnsynchronizedPoolResource stellt die funktionell identische Methode [SWS_CORE_00056] ebenfalls einen Zeiger auf die Upstream-Ressource bereit, richtet sich aber an nicht intern synchronisierte Pool-Szenarien.
In ara::core::MonotonicBufferResource existiert mit [SWS_CORE_06531] ein entsprechendes Pendant, das ebenfalls als noexcept sowie threadsicher spezifiziert ist.
Dieser Nutzungshinweis wurde automatisiert anhand des AUTOSAR-Payloads generiert.
gemini-3.8-flash-medium· 2026-10-13