Biedt een thread-safe pool-geheugenresource voor het efficiënt toewijzen en vrijgeven van geheugenblokken.
DOOR AI GEGENEREERDongecontroleerdModel: gemini-3.8-flash-medium · Inspanning: medium · Temperatuur: niet regelbaar · Prompt: 8c6c1308f3f6HerkomstOpen vragen (3)
vertaald uit de Duitse handleidinggemini-3.8-flash-low · 2026-10-13 · Duits origineel
Biedt een thread-safe pool-geheugenresource voor het efficiënt toewijzen en vrijgeven van geheugenblokken.
De klasse ara::core::SynchronizedPoolResource stelt een thread-safe geheugenresource beschikbaar die allocaties via interne pools afhandelt en extra geheugen aanvraagt bij een bovenliggende upstream-resource ([SWS_CORE_00030]). In tegenstelling tot de C++-standaard werpt de geheugenallocatie bij mislukkingen geen excepties, maar retourneert in plaats daarvan nullptr ([SWS_CORE_00061]). Kopieeroperaties zijn volledig verhinderd, terwijl verplaatsingsoperaties expliciet worden ondersteund. Bovendien is de destructor niet virtueel, waardoor instanties niet polymorf via een basisklassepointer mogen worden vrijgegeven.
Context
De klasse ara::core::SynchronizedPoolResource stelt een thread-safe geheugenresource beschikbaar voor het AUTOSAR Adaptive Platform binnen de module core. Deze is gebaseerd op het concept van std::pmr::synchronized_pool_resource conform de C++-standaard [mem.res.pool] en leidt publiek af van de basisklasse MemoryResource. De kerntaak bestaat erin geheugenblokken via interne pools op grootteklassen te beheren om terugkerende toewijzingen efficiënt en gelijktijdig af te handelen. Als de interne voorraad niet toereikend is, betrekt de instantie grotere geheugenblokken van een bovenliggende upstream-geheugenresource ([SWS_CORE_00038]).
Tot de typische interactiepartners behoren gelijktijdige threads van een applicatie die toewijzingen aanvragen, de SynchronizedPoolResource als bemiddelende pool-manager en een onderliggende MemoryResource als upstream-bron. Alle centrale toegangs- en beheerfuncties zoals do_allocate, do_deallocate, options en release zijn thread-safe ontworpen ([SWS_CORE_00061], [SWS_CORE_00041], [SWS_CORE_00039], [SWS_CORE_00037]).
Contextdiagram: Samenspel van gelijktijdige applicatie-threads, de pool-resource en de upstream-geheugenbron. Bronnen: [SWS_CORE_00030], [SWS_CORE_00038].
Levenscyclus
De instantiëring van SynchronizedPoolResource kan via meerdere constructor-overloads plaatsvinden. Als zowel allocatie-opties (PoolOptions) als een upstream-resource beschikbaar zijn, garandeert de initialisatie volledige exceptieveiligheid en is deze als noexcept gedeclareerd ([SWS_CORE_00030]). Daarnaast bestaan er constructors zonder parameters ([SWS_CORE_00031]), met uitsluitend een upstream-pointer ([SWS_CORE_00032]) of met zuivere pool-opties ([SWS_CORE_00033]). Interpretatie: Als er geen upstream-pointer wordt meegegeven, valt de implementatie vermoedelijk terug op een platformspecifieke standaard-geheugenresource. Vraag Q-5dafb414672249dc (open)
Met betrekking tot de eigendomsverhoudingen sluit de klasse kopiëren strikt uit: zowel de copy constructor ([SWS_CORE_00034]) als de copy assignment operator ([SWS_CORE_00036]) zijn verwijderd (=delete). In tegenstelling tot de ISO-C++17-standaard definieert AUTOSAR voor deze klasse echter expliciet move-semantiek: een move constructor ([SWS_CORE_00043]) en een move assignment operator ([SWS_CORE_00044]) zijn telkens als noexcept=default beschikbaar.
Een centraal aspect van de vernietiging is de afwijking van het standaardgedrag: de destructor ~SynchronizedPoolResource() is expliciet niet virtueel ([SWS_CORE_00035]). Interpretatie: Aangezien de destructor niet virtueel is, zou een polymorfe vernietiging via een pointer van de basisklasse MemoryResource* waarschijnlijk tot ongedefinieerd gedrag leiden; instanties moeten daarom altijd via hun concrete type worden afgebroken. Vraag Q-5add73880279b024 (open) Met de aanroep van release() kan bovendien al het gealloceerde geheugen aan de upstream-resource worden teruggegeven, terwijl het resource-object intact blijft ([SWS_CORE_00037]).
Gebruikspad
Het typische verloop omvat de initialisatie, de herhaalde toewijzing en vrijgave van geheugenblokken en het afsluitende opschonen:
Initialisatie: De applicatie maakt de instantie aan onder vermelding van configuratieparameters en een bovenliggende geheugenresource ([SWS_CORE_00030]). De actieve instellingen kunnen via options() worden opgevraagd ([SWS_CORE_00039]), de upstream-pointer via upstream_resource() ([SWS_CORE_00038]).
Geheugenallocatie: Geheugenaanvragen worden beschermd via do_allocate afgehandeld ([SWS_CORE_00061]). Interpretatie: De aanroep in de applicatiecode vindt gewoonlijk niet rechtstreeks via de beschermde methode do_allocate plaats, maar via de overgeërfde publieke interface allocate van de basisklasse MemoryResource. Vraag Q-1542a47cdff73dfb (open)
Identiteitscontrole: Via do_is_equal kan worden vastgesteld of twee geheugenresources equivalent aan elkaar zijn ([SWS_CORE_00042]).
Vrijgave: Afzonderlijke geheugengebieden worden via do_deallocate teruggevoerd naar de pool ([SWS_CORE_00041]). Desgewenst kan via release() al het geheugen van alle pools gebundeld aan de upstream-resource worden teruggegeven ([SWS_CORE_00037]).
Het AUTOSAR Adaptive Platform wijkt bij de foutafhandeling doelgericht af van de exceptieconventies van de C++-standaard:
Allocatiefouten: Waar ISO-C++ bij uitputting voorziet in het werpen van std::bad_alloc, is do_allocate in AUTOSAR gedefinieerd als noexcept. Als er geen passend geheugenblok kan worden geleverd, retourneert de methode in plaats daarvan verplicht een null pointer (nullptr) ([SWS_CORE_00061]). Oproepende entiteiten moeten daarom elke toewijzingsretourwaarde controleren op nullptr.
Deallocatiefouten: De methode do_deallocate is eveneens noexcept. Als er bij het teruggeven van een geheugenblok een fout optreedt, wordt deze volgens de specificatie geruisloos genegeerd ([SWS_CORE_00041]).
Constructierisico's: Terwijl de constructor met opties en upstream-resource exceptieveilig is ([SWS_CORE_00030]), zijn de constructors zonder upstream-vermelding of zonder opties geclassificeerd als niet-exceptieveilig („not exception safe”) ([SWS_CORE_00031], [SWS_CORE_00032], [SWS_CORE_00033]). Interpretatie: Mislukt bij deze constructors de interne voorziening van pool-beheerstructuren, dan kan het aanmaken van het object falen. Vraag (open)
Deze klassehandleiding vat de specificatie van ara::core::SynchronizedPoolResource voor AUTOSAR Adaptive Release R25-11 samen.
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
DOOR AI GEGENEREERDongecontroleerdModel: gemini-3.8-flash-medium · Inspanning: medium · Temperatuur: niet regelbaar · Prompt: d6b2e58cc49aHerkomstOpen vragen (1)
vertaald uit de Duitse handleidinggemini-3.8-flash-low · 2026-10-13 · Duits origineel
Gebruik en allocatiesemantiek
De elementfunctie do_allocate van de klasse ara::core::SynchronizedPoolResource uit het headerbestand #include "ara/core/memory_resource.h" dient voor de allocatie van geheugengebieden met de gespecificeerde bytegrootte bytes en uitlijning alignment[SWS_CORE_00061]. In geval van succes levert de synchrone aanroep conform [mem.res.pool] een geldige pointer van het type void* naar het toegewezen geheugenblok op [SWS_CORE_00061].
Foutafhandeling en afwijkingen
Wat betreft het foutgedrag wijkt de implementatie expliciet af van de voorschriften uit [mem.res.pool]: de methode is gedeclareerd als noexcept en genereert geen std::bad_alloc-exception [SWS_CORE_00061]. Bij een mislukking van de geheugenaanvraag is de geretourneerde pointer daarentegen verplicht nullptr[SWS_CORE_00061]. Oproepende code moet de retourwaarde daarom verplicht op een null-pointer controleren om allocatiefouten betrouwbaar af te vangen.
Gelijktijdigheid en wisselwerking
De functie is gespecificeerd als exception safe en in tegenstelling tot andere geheugenresources als thread-safe[SWS_CORE_00061]. Vanwege haar protected-zichtbaarheid lijkt ze in de praktijk vooral te fungeren als interne overschrijving van de zuiver virtuele basisinterface do_allocate uit ara::core::MemoryResource[SWS_CORE_06566]. Vraag Q-95ba181693426bfc (open) Terwijl ara::core::SynchronizedPoolResource de gelijktijdige toegang beveiligt [SWS_CORE_00061], zijn vergelijkbare implementaties zoals ara::core::UnsynchronizedPoolResource::do_allocate[SWS_CORE_00058] en ara::core::MonotonicBufferResource::do_allocate[SWS_CORE_06569] gedefinieerd als not thread-safe.
Deze tekst is gegenereerd door een AI-systeem op basis van de specificatie AUTOSAR Adaptive R25-11.
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
DOOR AI GEGENEREERDongecontroleerdModel: gemini-3.8-flash-medium · Inspanning: medium · Temperatuur: niet regelbaar · Prompt: b07cac0de0a1HerkomstOpen vragen (1)
vertaald uit de Duitse handleidinggemini-3.8-flash-low · 2026-10-13 · Duits origineel
De beschermde elementfunctie do_deallocate van de klasse ara::core::SynchronizedPoolResource dient voor de vrijgave van een eerder gealloceerd geheugengebied conform [SWS_CORE_00041]. De aanroep ervan geschiedt synchroon en verwacht als parameters een pointer p naar het geheugengebied, de grootte bytes in bytes en het geheugen-alignment alignment. Aangezien de elementfunctie met zichtbaarheid protected is gedeclareerd, wordt ze in reguliere applicatiecode vermoedelijk niet direct aangeroepen, maar via de publieke interface voor deallocatie van de bovenliggende basisklasse ara::core::MemoryResource uitgevoerd ([SWS_CORE_06567]). Vraag Q-badea921c907c214 (open)
Wat betreft foutafhandeling en uitzonderingsgedrag definieert de specificatie twee bindende afwijkingen van de standaard:
De functie is als noexcept gedeclareerd en volledig uitzonderingsveilig (exception safe) ([SWS_CORE_00041]).
Mocht de deallocatie niet succesvol zijn, dan worden opgetreden fouten stilzwijgend genegeerd ([SWS_CORE_00041]). Er vindt noch het werpen van een exception plaats, noch de terugmelding van een foutcode.
Op het gebied van gelijktijdigheid onderscheidt de implementatie in ara::core::SynchronizedPoolResource zich doordat deze expliciet als thread-safe (thread-safe) is gespecificeerd ([SWS_CORE_00041]). Daarmee is ze geschikt voor gelijktijdige aanroep vanuit meerdere threads. Hierin verschilt ze wezenlijk van de verwante resources ara::core::UnsynchronizedPoolResource ([SWS_CORE_00059]) en ara::core::MonotonicBufferResource ([SWS_CORE_06570]), die als niet thread-safe zijn geclassificeerd.
Deze tekst is gegenereerd door een AI op basis van de specificatie AUTOSAR R25-11.
DOOR AI GEGENEREERDongecontroleerdModel: gemini-3.8-flash-medium · Inspanning: medium · Temperatuur: niet regelbaar · Prompt: c89ab0c97360HerkomstOpen vragen (1)
vertaald uit de Duitse handleidinggemini-3.8-flash-low · 2026-10-13 · Duits origineel
De protected lidfunctie do_is_equal controleert de gelijkheid van een instantie van ara::core::SynchronizedPoolResource met een andere geheugenbron [SWS_CORE_00042]. Ze overschrijft de zuiver virtuele basisklassemethode uit ara::core::MemoryResource[SWS_CORE_06568] conform de specificatie voor pool-bronnen in [mem.res.pool].
Gebruik en interface: Als parameter wordt een referentie naar een ander ara::core::MemoryResource-object meegegeven (const MemoryResource &other). De retourwaarde van het type bool geeft aan of beide bronnen equivalent zijn. Interpretatie: Vanwege de zichtbaarheid protected wordt de functie in het reguliere applicatieverloop niet rechtstreeks aangeroepen, maar via de publieke vergelijkingsmethode van de basisklasse uitgevoerd. Vraag Q-29fb2980d1241fae (open)
Foutafhandeling en veiligheid: De methode is gedeclareerd met de identifier noexcept en gespecificeerd als exception safe[SWS_CORE_00042]. Er treden noch exceptions noch specifieke foutcodes op. De uitvoering vindt synchroon plaats.
Gelijktijdigheid: Conform [SWS_CORE_00042] is do_is_equal gespecificeerd als thread-safe, zodat gelijktijdige vergelijkingen over meerdere threads heen zonder aanvullende externe synchronisatie zijn toegestaan.
Interactie: De functie vormt de thread-safe tegenhanger van de implementatie in ara::core::UnsynchronizedPoolResource[SWS_CORE_00060]. Evenzo stelt ara::core::MonotonicBufferResource een corresponderende overschrijving beschikbaar, die eveneens is gemarkeerd als noexcept[SWS_CORE_06571].
Deze tekst is gegenereerd door een AI op basis van de specificatie AUTOSAR Adaptive R25-11.
DOOR AI GEGENEREERDongecontroleerdModel: gemini-3.8-flash-medium · Inspanning: medium · Temperatuur: niet regelbaar · Prompt: 4714ac548826HerkomstOpen vragen (1)
vertaald uit de Duitse handleidinggemini-3.8-flash-low · 2026-10-13 · Duits origineel
De lidfunctie options van de klasse ara::core::SynchronizedPoolResource levert de voor de geheugenbron geconfigureerde instellingen van het type PoolOptions synchroon terug [SWS_CORE_00039]. De aanroep geschiedt parameterloos op een instantie van de klasse en is gedeclareerd via header ara/core/memory_resource.h[SWS_CORE_00039]. Het gedrag baseert zich volgens de specificatie op [mem.res.pool][SWS_CORE_00039], wat kan worden geïnterpreteerd als aansluiting bij de pool-resources van de C++-standaard. Vraag Q-9abfddc2cf8dc88c (open)
Wat betreft de foutafhandeling en exceptieveiligheid is de methode gedeclareerd als noexcept en geldt deze als volledig exceptieveilig (exception safe) [SWS_CORE_00039]. Specifieke foutcodes of meldingen aan DET of DEM bestaan voor deze opvraagfunctie niet.
Met betrekking tot gelijktijdigheid is de methode gespecificeerd als const en uitdrukkelijk als thread-safe (thread-safe) [SWS_CORE_00039]. Deze kan zodoende zonder aanvullende synchronisatiemaatregelen op gebruikersniveau veilig en parallel vanuit meerdere threads worden aangeroepen.
In de interactie binnen ara::core biedt [SWS_CORE_00057] de niet-gesynchroniseerde tegenhanger: Voor ara::core::UnsynchronizedPoolResource bestaat een functie met dezelfde naam en signatuur options met identieke semantiek conform [mem.res.pool].
Deze tekst is gegenereerd door een AI en dient als oriënterende gebruikshulp.
DOOR AI GEGENEREERDongecontroleerdModel: gemini-3.8-flash-medium · Inspanning: medium · Temperatuur: niet regelbaar · Prompt: 32c426df4959HerkomstOpen vragen (1)
vertaald uit de Duitse handleidinggemini-3.8-flash-low · 2026-10-13 · Duits origineel
De synchrone elementfunctie release() behoort tot de klasse ara::core::SynchronizedPoolResource en wordt via het headerbestand #include "ara/core/memory_resource.h" ter beschikking gesteld [SWS_CORE_00037]. Ze heeft de signatuur void release () noexcept;, accepteert geen parameters en heeft geen retourwaarde. De functionele semantiek richt zich naar het overeenkomstige gebruik in [mem.res.pool][SWS_CORE_00037], waarmee het door de geheugenresource beheerde geheugen wordt vrijgegeven.
Wat betreft foutafhandeling is de functie als uitzonderingsveilig (exception safe) en noexcept gedeclareerd [SWS_CORE_00037]. Er treden geen C++-exceptions op; specifieke foutcodes of foutrapportages via DET resp. DEM worden binnen de specificatieomvang niet gedefinieerd.
Met betrekking tot gelijktijdigheid is de bewerking uitdrukkelijk als thread-safe (thread-safe) gespecificeerd [SWS_CORE_00037]. Een gelijktijdige aanroep vanuit meerdere threads op dezelfde resource-instantie lijkt daarom toelaatbaar zonder aanvullende vergrendelingen aan de applicatiezijde. Vraag Q-3da3b45ca2070b3e (open)
In de wisselwerking komt het gedrag overeen met de functioneel identieke methode in ara::core::UnsynchronizedPoolResource[SWS_CORE_00065], die eveneens naar [mem.res.pool] verwijst en als noexcept alsook thread-safe is aangemerkt. In tegenstelling daartoe is de analoge release()-functie van ara::core::MonotonicBufferResource[SWS_CORE_06530] volgens de specificatie niet thread-safe (not thread-safe), hoewel deze eveneens onder de noexcept-garantie valt.
Deze tekst is gegenereerd door een AI en is uitsluitend gebaseerd op de specificatiegegevens van AUTOSAR R25-11.
DOOR AI GEGENEREERDongecontroleerdModel: gemini-3.8-flash-medium · Inspanning: medium · Temperatuur: niet regelbaar · Prompt: 6f69b7b33ad7Herkomst
vertaald uit de Duitse handleidinggemini-3.8-flash-low · 2026-10-13 · Duits origineel
Gebruik
De elementfunctie upstream_resource() van de klasse ara::core::SynchronizedPoolResource levert een pointer naar de onderliggende upstream geheugenresource (MemoryResource*) conform [SWS_CORE_00038]. De aanroep verloopt synchroon en vereist het includen van het headerbestand #include "ara/core/memory_resource.h"[SWS_CORE_00038]. De functie accepteert geen overdrachtsparameters en dient als zuivere inspecteur voor de bovenliggende geheugenbeheereenheid.
Foutafhandeling en uitzonderingsveiligheid
De methode is als noexcept gedeclareerd en volgens de specificatie als uitzonderingsveilig (exception safe) geclassificeerd [SWS_CORE_00038]. Het mislukken van de bevraging of het genereren van uitzonderingen is uitgesloten; foutcodes bestaan er voor deze aanroep niet.
Gelijktijdigheid en beperkingen
De functie is als const en expliciet als thread-safe (thread-safe) gespecificeerd [SWS_CORE_00038]. Ze kan zodoende gelijktijdig vanuit meerdere uitvoeringscontexten zonder aanvullende externe synchronisatie worden aangeroepen.
Samenspel
Het concept van een voorgeschakelde geheugenresource wordt consistent over verschillende geheugenpool-implementaties van AUTOSAR Adaptive Core heen aangeboden:
In ara::core::UnsynchronizedPoolResource stelt de functioneel identieke methode [SWS_CORE_00056] eveneens een pointer naar de upstream-resource beschikbaar, maar richt zich op niet intern gesynchroniseerde pool-scenario's.
In ara::core::MonotonicBufferResource bestaat met [SWS_CORE_06531] een overeenkomstige tegenhanger, die eveneens als noexcept en thread-safe is gespecificeerd.
Deze gebruiksinstructie is automatisch gegenereerd op basis van de AUTOSAR-payload.
gemini-3.8-flash-low· 2026-10-13 · Duits origineel