klasse ara::core::PolymorphicAllocator

De memberfunctie allocate van de klasse ara::core::PolymorphicAllocator dient voor het synchroon aanvragen van ongeïnitialiseerd geheugen voor n objecten van het type Tp [SWS_CORE_06547]. Zij oriënteert zich op de functionaliteit van [mem.poly.allocator.class], maar wijkt door de declaratie als noexcept en het attribuut [[nodiscard]] doelgericht af van de C++-standaard [SWS_CORE_06547].

In geval van een fout werpt allocate geen exceptie zoals std::bad_alloc, maar geeft in plaats daarvan een nullptr terug [SWS_CORE_06547]. Vanwege [[nodiscard]] moet de aanroeper de retourwaarde expliciet in ontvangst nemen en controleren op nullptr alvorens het geheugenbereik te gebruiken [SWS_CORE_06547]. Wat betreft de gelijktijdigheid is de functie geclassificeerd als exception-safe, maar geldt als niet-thread-safe (not thread-safe) [SWS_CORE_06547]. Interpretatie: een synchrone aanroep via dezelfde allocator vanuit verschillende threads zou daarom vermoedelijk een externe beveiliging door de aanroeper vereisen. Vraag Q-b00116faadf930fe (open)

Het fouttolerante gedrag zonder excepties correspondeert rechtstreeks met de interface ara::core::MemoryResource::allocate [SWS_CORE_06503], die eveneens is gedefinieerd als noexcept en in geval van een fout nullptr retourneert. Ook vooraf gedefinieerde instanties zoals NullMemoryResource [SWS_CORE_06563] hanteren dit principe en leveren bij allocatie-aanroepen consequent nullptr op. Op een overkoepelend niveau interageert dit mechanisme met containers zoals ara::core::Vector [SWS_CORE_01315], waarvan de toewijzingsoperatoren zijn afgestemd op dergelijke allocatie-eigenschappen.

Gebruik

De elementfunctie allocate_bytes van de klasse ara::core::PolymorphicAllocator reserveert ongeformatteerd geheugen ter omvang van nbytes met de voorgeschreven alignment alignment [SWS_CORE_06549]. De standaardwaarde voor de alignment komt overeen met alignof(std::max_align_t) [SWS_CORE_06549]. De functie wordt via de header ara/core/memory_resource.h ingesloten en synchroon uitgevoerd [SWS_CORE_06549].

Foutafhandeling en semantiek

In tegenstelling tot het standaardgedrag volgens [mem.poly.allocator.class] vertoont de implementatie twee afwijkingen [SWS_CORE_06549]:

• De functie is gedeclareerd als noexcept en werpt geen uitzonderingen [SWS_CORE_06549].
• Mislukt de allocatie, dan retourneert de functie nullptr in plaats van een uitzondering te genereren [SWS_CORE_06549].

Op grond van het attribuut [[nodiscard]] moet de retourwaarde door de aanroeper worden geëvalueerd, in het bijzonder door een controle op nullptr voorafgaand aan toegang tot het geheugengebied [SWS_CORE_06549].

Gelijktijdigheid en beperkingen

Wat betreft thread-safety is de methode gespecificeerd als not thread-safe [SWS_CORE_06549]. Parallelle aanroepen op dezelfde instantie vereisen daarom vermoedelijk een externe synchronisatie [SWS_CORE_06549]. Vraag Q-85c74d55563cae38 (open) Met betrekking tot uitzonderingsveiligheid geldt de bewerking als exception safe [SWS_CORE_06549].

Gebruik

De template-elementfunctie allocate_object maakt deel uit van de klasse ara::core::PolymorphicAllocator en wordt beschikbaar gesteld via het headerbestand #include "ara/core/memory_resource.h" [SWS_CORE_06551]. Ze allokeert synchroon geheugen voor n objecten van het type T, waarbij de parameter n standaard van de waarde 1 is voorzien [SWS_CORE_06551]. Het compilerattribuut [[nodiscard]] verplicht aanroepers ertoe de geretourneerde getypeerde pointer T* niet te negeren.

Foutafhandeling

De specificatie definieert twee expliciete afwijkingen van de standaard [mem.poly.allocator.class] [SWS_CORE_06551]:

• Geen exceptions: De functie is gedeclareerd als noexcept en gespecificeerd als uitzonderingsveilig (exception safe) [SWS_CORE_06551].
• Nullpointer bij fouten: Mislukt de geheugenallocatie, dan wordt er geen exception geworpen, maar dwingend nullptr geretourneerd [SWS_CORE_06551].

De aanroeper moet de geleverde pointer daarom onmiddellijk vóór verder gebruik op nullptr controleren.

Gelijktijdigheid en beperkingen

De bewerking is gespecificeerd als niet thread-safe (not thread-safe) [SWS_CORE_06551]. Bij gelijktijdig gebruik van dezelfde allocator-instantie is vermoedelijk een externe synchronisatie vereist om dataraces te vermijden. Bovendien reserveert de functie zuiver geheugen (interpretatie: de constructie van objecten in het gereserveerde geheugen is de verantwoordelijkheid van achterliggende mechanismen). Vraag Q-c41df2caaeb4c503 (open)

De templatefunctie construct van de klasse ara::core::PolymorphicAllocator ([SWS_CORE_06555]) dient voor het synchroon aanmaken van een object van het type T op het meegegeven geheugenadres p onder doorsturen van de argumenten args.... Ze is gedefinieerd via de header ara/core/memory_resource.h en volgt in hoofdzaak de voorschriften uit [mem.poly.allocator.class].

Een expliciete afwijking van de C++-standaard betreft de uitzonderingsafhandeling: volgens [SWS_CORE_06555] is de functie voorwaardelijk gedeclareerd als noexcept, afhankelijk van het feit of std::is_nothrow_constructible<T, Args...>::value van toepassing is. De specificatie kent haar daarmee het attribuut conditionally exception safe toe. Interpretatie: Voor zover T niet uitzonderingsvrij construeerbaar is, kunnen eventuele constructor-uitzonderingen vermoedelijk ongehinderd naar de aanroeper worden gepropageerd, aangezien er geen interne foutcodes of afzonderlijke opvangmechanismen zijn gedefinieerd. Vraag Q-ad77510f396e59ae (open)

Wat betreft gelijktijdigheid en randvoorwaarden is construct gespecificeerd als niet thread-safe (not thread-safe) ([SWS_CORE_06555]). Bij parallelle toegangen tot dezelfde allocator-instantie of hetzelfde geheugengebied is externe synchronisatie in de aanroepcontext daarom dwingend vereist.

Het architectuurpatroon van een typeafhankelijke noexcept-declaratie komt overeen met de conventies in ara::core, zoals deze onder andere ook bij de constructors van ara::core::Result worden toegepast ([SWS_CORE_00725], [SWS_CORE_00726]).

Gebruik

De lidfunctie deallocate van de klasse ara::core::PolymorphicAllocator geeft eerder gealloceerd geheugen voor n objecten van het type Tp vanaf het adres p vrij [SWS_CORE_06548]. De declaratie vindt plaats via de header ara/core/memory_resource.h [SWS_CORE_06548]. De functie volgt in principe de semantiek van de standaard-C++-allocator conform [mem.poly.allocator.class], maar vertoont twee specifieke afwijkingen [SWS_CORE_06548].

Foutafhandeling en exception-veiligheid

Als wezenlijke afwijking is de bewerking gedeclareerd als noexcept en gespecificeerd als uitzonderingsveilig (exception safe) [SWS_CORE_06548]. Mislukt de vrijgave van het geheugen, dan worden optredende fouten geruisloos genegeerd (silently ignored), zodat er noch excepties worden geworpen noch expliciete foutcodes worden teruggemeld [SWS_CORE_06548].

Gelijktijdigheid en wisselwerking

Wat betreft de aanroepcontext is deallocate geclassificeerd als niet-thread-safe (not thread-safe) [SWS_CORE_06548]. In het geheugenbeheerconcept correspondeert deze functie met de methode deallocate van de onderliggende basisklasse ara::core::MemoryResource [SWS_CORE_06504], waarvoor dezelfde afwijkingen met betrekking tot noexcept en geruisloze foutafhandeling gelden.

De functie deallocate_bytes van de klasse ara::core::PolymorphicAllocator dient voor het vrijgeven van een eerder gealloceerd geheugengebied volgens [SWS_CORE_06550]. Ze wordt beschikbaar gesteld via de header ara/core/memory_resource.h en richt zich in principe naar de semantiek uit [mem.poly.allocator.class].

De aanroep vindt synchroon plaats en verwacht volgens [SWS_CORE_06550] de volgende parameters:

• p: Pointer (void*) naar het vrij te geven geheugengebied.
• nbytes: Grootte van het vrij te geven geheugen in bytes (std::size_t).
• alignment: Gewenste alignment (standaardwaarde alignof(std::max_align_t)).

Wat betreft het foutgedrag vertoont de implementatie specifieke afwijkingen ten opzichte van de standaard: de functie is gedeclareerd als noexcept en geldt als uitzonderingsveilig (exception safe). Mislukt de vrijgave, dan worden optredende fouten stilzwijgend genegeerd (silently ignored) volgens [SWS_CORE_06550]. Er worden geen exceptions geworpen en er worden geen retourwaarden verstrekt.

Met betrekking tot gelijktijdigheid en beperkingen is de functie expliciet gespecificeerd als niet thread-safe (not thread-safe) [SWS_CORE_06550]. Een gelijktijdige toegang tot dezelfde allocator-instantie zonder externe synchronisatie leidt daarom vermoedelijk tot ongedefinieerd gedrag. Vraag Q-33c80e3bb50ed64f (open)

De templatefunctie deallocate_object van de klasse ara::core::PolymorphicAllocator dient voor het vrijgeven van eerder gereserveerd objectgeheugen [SWS_CORE_06552]. Ze richt zich naar het overeenkomstige C++-standaardgebruik volgens [mem.poly.allocator.class], maar vertoont specifieke afwijkingen [SWS_CORE_06552].

Wat betreft parameters en aanroepcontext gelden volgens [SWS_CORE_06552] de volgende eigenschappen:

• Signatuur: template <class T> void deallocate_object (T *p, std::size_t n=1) noexcept; [SWS_CORE_06552].
• Header: De functie is beschikbaar via #include "ara/core/memory_resource.h" [SWS_CORE_06552].
• Retourwaarde: De bewerking levert geen retourwaarde op (void) [SWS_CORE_06552].
• Nullpointer-gedrag: Als expliciete afwijking is gespecificeerd dat de functie bij overdracht van nullptr ingrijpt resp. nullpointers ondersteunt (“Function is nullptr”) [SWS_CORE_06552].

Met betrekking tot de foutafhandeling is de functie gedeclareerd als noexcept en geldt ze als uitzonderingsveilig (exception safe) [SWS_CORE_06552]. Mislukt een deallocatie, dan worden optredende fouten stilzwijgend genegeerd (“errors will be silently ignored”), zodat er geen uitzonderingen naar buiten worden gepropageerd [SWS_CORE_06552].

Als wezenlijke beperking is deallocate_object geclassificeerd als niet thread-safe (not thread-safe) [SWS_CORE_06552]. Bij parallelle toegangen tot dezelfde allocator-instantie vanuit meerdere threads moeten aanroepen daarom worden beveiligd met externe synchronisatiemechanismen.

De elementfunctie delete_object van de klasse ara::core::PolymorphicAllocator dient volgens [SWS_CORE_06554] voor de vernietiging en vrijgave van een object van het type T, waarnaar de meegegeven pointer p verwijst. De functie wordt beschikbaar gesteld via het headerbestand #include "ara/core/memory_resource.h" en volgt het gedrag uit [mem.poly.allocator.class] met specifieke afwijkingen.

Wat betreft de aanroepcontext en de semantiek gelden de volgende eigenschappen:

• Retourwaarde en uitzonderingen: De functie heeft geen retourwaarde (void). Ze is voorwaardelijk uitzonderingsveilig (conditionally noexcept) met de specificatie noexcept(std::is_nothrow_destructible<T>::value), werpt dus geen uitzonderingen mits de destructor van T als niet-werpend is gedeclareerd [SWS_CORE_06554].
• Foutafhandeling: Mislukt de bewerking, dan worden optredende fouten stilzwijgend genegeerd (errors will be silently ignored) [SWS_CORE_06554]. Interpretatie: Aanroepers ontvangen in geval van een fout zodoende noch een foutmelding noch een foutcode of een exception. Vraag Q-9393b0f68a055e4b (open)
• Thread-safety: De bewerking is gespecificeerd als niet thread-safe (not thread-safe) [SWS_CORE_06554]. Bij gelijktijdig gebruik van dezelfde allocator over meerdere threads heen berust de synchronisatie bij de aanroeper.

Gebruik

De template-elementfunctie destroy van de klasse ara::core::PolymorphicAllocator ([SWS_CORE_06556]) dient voor het destrueren van een object van het type T, waarnaar de pointer p verwijst. De functie is gedeclareerd in de header ara/core/memory_resource.h en volgt in principe het gestandaardiseerde gedrag uit [mem.poly.allocator.class] ([SWS_CORE_06556]). De methode-aanroep levert geen retourwaarde op en wordt synchroon uitgevoerd in de context van de aanroepende thread. Interpretatie: Hierbij wordt vermoedelijk voorondersteld dat p verwijst naar een geldig, eerder geïnstantieerd object. Vraag Q-a4faf7034eb683dd (open)

Foutafhandeling en exception-veiligheid

Wat betreft de foutafhandeling is de functie geclassificeerd als voorwaardelijk uitzonderingsveilig (conditionally exception safe) ([SWS_CORE_06556]). Als specifieke afwijking van de standaardeis [mem.poly.allocator.class] is destroy voorwaardelijk gedeclareerd met noexcept(std::is_nothrow_destructible<T>::value) ([SWS_CORE_06556]). Mits de destructor van het meegegeven type T geen uitzonderingen werpt, geldt de uitzonderingsvrijheid voor de gehele aanroep; anders kunnen uit de destructor resulterende exceptions ontsnappen.

Gelijktijdigheid en beperkingen

Met betrekking tot het gelijktijdigheidsgedrag is destroy gespecificeerd als niet thread-safe (not thread-safe) ([SWS_CORE_06556]). Wanneer meerdere threads tegelijkertijd toegang hebben tot dezelfde instantie van ara::core::PolymorphicAllocator of tot het te vernietigen object, moeten geschikte externe synchronisatiemechanismen worden ingesteld.

De template-elementfunctie new_object van de klasse ara::core::PolymorphicAllocator (gedefinieerd in #include "ara/core/memory_resource.h") allokeert synchroon geheugen en construeert een object van het type T met de meegegeven constructorargumenten ctor_args [SWS_CORE_06553].

Het gebruik is onderworpen aan de volgende bepalingen en afwijkingen van de standaard [mem.poly.allocator.class] [SWS_CORE_06553]:

• Aanroep en retourwaarde: Bij succesvolle objectcreatie wordt een getypeerde pointer T* naar de nieuwe instantie geretourneerd. Het attribuut [[nodiscard]] verplicht aanroepers ertoe de retourwaarde te evalueren.
• Foutafhandeling: In geval van mislukking wordt in afwijking van [mem.poly.allocator.class] geen exception gegenereerd, maar nullptr geretourneerd. De aanroeper moet de resulterende pointer daarom vóór toegang dwingend controleren op nullptr.
• Uitzonderingsveiligheid: De functie is gespecificeerd als voorwaardelijk uitzonderingsveilig (conditionally exception safe). Ze is dan en slechts dan noexcept als de objectcreatie zelf gegarandeerd geen uitzondering werpt (noexcept(std::is_nothrow_constructible<T, CtorArgs...>::value)).
• Gelijktijdigheid: De functie is gedeclareerd als niet thread-safe (not thread-safe). Interpretatie: Bij gelijktijdige toegang tot dezelfde instantie van ara::core::PolymorphicAllocator is de aanroeper vermoedelijk verantwoordelijk voor een geschikte externe synchronisatie. Vraag Q-3d0ecfe34187c91e (open)

De methode resource is een constante elementfunctie van de klasse ara::core::PolymorphicAllocator uit het headerbestand #include "ara/core/memory_resource.h" [SWS_CORE_06557]. Ze dient volgens de specificatiereferentie naar [mem.poly.allocator.class] voor het synchroon opvragen van de toegewezen geheugenresource [SWS_CORE_06557].

Gebruik en signatuur

De functiesignatuur luidt MemoryResource * resource () const noexcept; [SWS_CORE_06557]. De aanroep vindt parameterloos en synchroon plaats op een instantie van ara::core::PolymorphicAllocator. Als retourwaarde levert de functie een pointer van het type MemoryResource* [SWS_CORE_06557] op. Interpretatie: De geretourneerde pointer verwijst vermoedelijk direct naar de concrete geheugenresource die de allocator voor geheugenbewerkingen gebruikt. Vraag Q-392683a38a4e490b (open)

Foutafhandeling en gelijktijdigheid

• Uitzonderingsveiligheid: De functie is gedeclareerd als noexcept en ingedeeld als exception safe [SWS_CORE_06557]. Ze werpt geen exceptions en er zijn geen specifieke foutcodes gedefinieerd.
• Thread-safety: De specificatie merkt de methode expliciet aan als thread-safe [SWS_CORE_06557]. Door de kwalificatie als const is de gelijktijdige leestoegang over meerdere threads heen veilig.

Samenspel

In de module core stelt resource de interface beschikbaar om de door ara::core::PolymorphicAllocator ingekapselde MemoryResource op te vragen en de bewerkingen ervan aan te spreken [SWS_CORE_06557].

Gebruik

De elementfunctie select_on_container_copy_construction behoort tot de scope van de klasse ara::core::PolymorphicAllocator en wordt gedeclareerd via het headerbestand #include "ara/core/memory_resource.h" ([SWS_CORE_06573]). Ze wordt synchroon aangeroepen om bij de kopieerconstructie van een container een nieuwe instantie van PolymorphicAllocator aan te maken ([SWS_CORE_06573]). Het functionele gedrag volgt daarbij de voorschriften van [mem.poly.allocator.class] ([SWS_CORE_06573]). Interpretatie: De resulterende allocator is vermoedelijk standaard geconstrueerd en valt zodoende terug op de standaard geheugenresource, in plaats van de geheugenresource van de broncontainer dwingend te kopiëren. Vraag Q-134ed967dc22e133 (open)

Foutafhandeling en exception-veiligheid

Een centrale afwijking van de algemene C++-specificatie bestaat erin dat de functie in AUTOSAR expliciet is gedeclareerd als noexcept ([SWS_CORE_06573]). De uitvoering is gedefinieerd als uitzonderingsveilig (exception safe) ([SWS_CORE_06573]). Specifieke foutcodes, retourwaarden ter foutindicatie of meldingen aan DET of DEM zijn voor deze interface niet voorzien, aangezien de aanroep gegarandeerd foutloos termineert.

Gelijktijdigheid en beperkingen

Volgens de specificatie is de functie geclassificeerd als not thread-safe ([SWS_CORE_06573]). Dit betekent dat gelijktijdige aanroepen op dezelfde PolymorphicAllocator-instantie vanuit meerdere threads zonder externe synchronisatie tot dataraces kunnen leiden. Voorafgaand aan het kopiëren van een container in gelijktijdige omgevingen moet de toegang tot het allocator-object door de gebruiker worden beschermd.