klasse ara::core::Promise

De klasse ara::core::Promise fungeert als asynchroon schrijf-eindpunt om waarden, fouten of resultaten thread-overschrijdend over te dragen naar een gedeelde toestand [SWS_CORE_00341]. De leestoegang vindt plaats via een exact eenmalig opvraagbare Future, die bij het beschikbaar stellen van het resultaat wordt vrijgegeven [SWS_CORE_00344]. Aangezien de klasse niet kopieerbaar is, blijft de toestand via move-semantiek strikt in uniek eigendom, waarbij meervoudig instellen van het resultaat of meervoudig opvragen van de future leidt tot gestandaardiseerde schendingen.

meer ›

Context

De klasse ara::core::Promise representeert de Adaptive Platform-specifieke variant van het uit de C++-standaard bekende concept std::promise. Zij is in de header ara/core/future.h als template Promise<T, E = ErrorCode> gedefinieerd en dient als asynchroon schrijf-eindpunt van een gedeelde toestand (shared state). Via dit kanaal draagt een producent thread-overschrijdend ofwel een berekende outputwaarde, een fout of een geaggregeerde ara::core::Result over. De bijbehorende ontvangerszijde benadert het resultaat via een geassocieerde ara::core::Future, die wordt opgehaald via de instantiemethode get_future [SWS_CORE_00344]. In tegenstelling tot het standaard C++-mechanisme, dat primair op uitzonderingen is gebaseerd, verankert AUTOSAR Adaptive het foutgetypeerde paradigma: voor zover het fouttype E ongelijk aan ara::core::ErrorCode wordt gekozen, dwingt de specificatie een compilatiefout af.

Levenscyclus

Een instantie wordt regulier aangemaakt via de parameterloze standaardconstructor, die zich gedraagt als de corresponderende constructor van std::promise, thread-veilig is en een nieuwe gedeelde toestand tot stand brengt [SWS_CORE_00341]. Om eenduidige eigendomsverhoudingen van deze toestand te garanderen, zijn kopieeracties volledig verboden: zowel de copy-constructor [SWS_CORE_00350] als de copy-assignment-operator [SWS_CORE_00351] zijn als verwijderd (delete) gedeclareerd.

De klasse ondersteunt echter verplaatsingssemantiek (move). De move-constructor neemt de gedeelde toestand van de broninstantie over [SWS_CORE_00342]. Bij een move-assignment geeft de doelinstantie haar eerdere gedeelde toestand op en neemt zij de toestand van het meegegeven object over analoog aan een swap-operatie [SWS_CORE_00343]. Daarnaast maakt de methode swap het wisselen van de interne toestand met een andere instantie mogelijk [SWS_CORE_00352]. Bij vernietiging via de destructor wordt een nog vastgehouden gedeelde toestand vrijgegeven resp. verlaten [SWS_CORE_00349]. Terwijl de standaardconstructor thread-veilig is ontworpen [SWS_CORE_00341], zijn move-operaties, toewijzingen, swap en vernietiging niet thread-veilig ([SWS_CORE_00342], [SWS_CORE_00343], [SWS_CORE_00352], [SWS_CORE_00349]).

Toestandsdiagram: levenscyclus en toestandsovergangen van de gedeelde toestand in een Promise-instantie. Bronnen: [SWS_CORE_00341], [SWS_CORE_00342], [SWS_CORE_00343], [SWS_CORE_00344], [SWS_CORE_00345], [SWS_CORE_00349], [SWS_CORE_00353], [SWS_CORE_00355]

Gebruikspad

Een typische procedure voor beschikbaarstelling omvat de volgende stappen:

1. Aanmaak: De producent instantieert een ara::core::Promise<T, E> [SWS_CORE_00341].
2. Future ophalen: Voorafgaand aan de start van de asynchrone verwerking roept de producent get_future() aan op [SWS_CORE_00344]. Omdat per Promise slechts één enkele geassocieerde Future is toegestaan, mag deze aanroep exact eenmalig plaatsvinden. De geretourneerde Future wordt overgedragen aan de consumerende thread.
3. Resultaat instellen: Na voltooiing van de asynchrone operatie brengt de producent het resultaat over naar de gedeelde toestand en zet deze in de toestand ready. Hiervoor staan telkens thread-safe overloads voor kopieer- en verplaatsbewerkingen ter beschikking:
   • Succesvolle waarde: aanroep van set_value ([SWS_CORE_00345], [SWS_CORE_00346]).
   • Fouttoestand: aanroep van SetError ([SWS_CORE_00353], [SWS_CORE_00354]).
   • Gecombineerd resultaat: aanroep van SetResult ([SWS_CORE_00355], [SWS_CORE_00356]).

Sequentiediagram: aanroep- en synchronisatievolgorde tussen producent, Promise, gedeelde toestand en consument. Bronnen: [SWS_CORE_00341], [SWS_CORE_00344], [SWS_CORE_00345], [SWS_CORE_00353], [SWS_CORE_00355]

Foutscenario's

De specificatie definieert strikte precondities voor alle interacties met de gedeelde toestand; het niet naleven daarvan leidt tot gestandaardiseerde schendingen (Violations):

• Meervoudig ophalen van de Future: Als get_future() meer dan eens wordt aangeroepen voor dezelfde gedeelde toestand, treedt de schending IsoStdFutureErrcFutureAlreadyRetrievedViolation op [SWS_CORE_00344].
• Ontbrekende gedeelde toestand: Bezit de aangeroepen instantie geen gedeelde toestand – bijvoorbeeld na het uitvoeren van een move-operatie –, dan leidt get_future() tot IsoStdFutureErrcNoStateViolation [SWS_CORE_00344]. De methoden set_value, SetError en SetResult activeren in dit geval de schending PromiseNoSharedStateToSetViolation ([SWS_CORE_00345], [SWS_CORE_00353], [SWS_CORE_00355]).
• Reeds vervulde toestand: Als de gedeelde toestand reeds is voorzien van een waarde, fout of resultaat, leidt elke hernieuwde aanroep van set_value ([SWS_CORE_00345], [SWS_CORE_00346]), SetError ([SWS_CORE_00353], [SWS_CORE_00354]) of SetResult ([SWS_CORE_00355], [SWS_CORE_00356]) tot de schending IsoStdFutureErrcPromiseAlreadySatisfiedViolation.
• Uitzonderingsveiligheid: De methoden set_value, SetError en SetResult zijn voorwaardelijk uitzonderingsveilig (conditionally exception safe). Ze werpen geen uitzonderingen op, mits de constructors van de typen T en E als nothrow zijn gedeclareerd ([SWS_CORE_00345], [SWS_CORE_00353], [SWS_CORE_00355]).

Interpretatie: Het opgeven van de gedeelde toestand bij vernietiging van de instantie zonder voorafgaande waardetoekenning ([SWS_CORE_00349]) leidt er analoog aan het C++-standaardgedrag van std::promise vermoedelijk toe dat een geassocieerde Future bij een leesverzoek een overeenkomstige foutgebeurtenis registreert. Vraag Q-fd013bb17a591af9 (open)