clase ara::core::Promise

La clase ara::core::Promise actúa como extremo de escritura asíncrono para transferir valores, errores o resultados entre hilos a un estado compartido [SWS_CORE_00341]. El acceso de lectura se realiza a través de un Future recuperable exactamente una vez, el cual se libera al suministrarse el resultado [SWS_CORE_00344]. Dado que la clase no es copiable, el estado permanece estrictamente en posesión unívoca mediante semántica de movimiento, provocando violaciones estandarizadas si se establece el resultado varias veces o se recupera el Future repetidamente.

más ›

Contexto

La clase ara::core::Promise representa la variante específica de Adaptive Platform del concepto std::promise conocido del estándar C++. Está definida en el encabezado ara/core/future.h como plantilla Promise<T, E = ErrorCode> y sirve como extremo de escritura asíncrono de un estado compartido (shared state). A través de este canal, un productor transfiere entre hilos un valor de salida calculado, un error o un ara::core::Result agregado. La parte receptora correspondiente accede al resultado mediante un ara::core::Future asociado, el cual se recupera a través del método de instancia get_future [SWS_CORE_00344]. A diferencia del mecanismo estándar de C++, que se basa principalmente en excepciones, AUTOSAR Adaptive afianza el paradigma tipificado por errores: si se elige un tipo de error E distinto de ara::core::ErrorCode, la especificación impone un error de compilación.

Ciclo de vida

Una instancia se crea regularmente a través del constructor predeterminado sin parámetros, el cual se comporta igual que el constructor correspondiente de std::promise, es seguro para hilos y establece un nuevo estado compartido [SWS_CORE_00341]. Para garantizar relaciones de propiedad unívocas sobre este estado, las operaciones de copia están completamente prohibidas: tanto el constructor de copia [SWS_CORE_00350] como el operador de asignación por copia [SWS_CORE_00351] están declarados como eliminados (delete).

Sin embargo, la clase admite semántica de movimiento (move). El constructor de movimiento asume el estado compartido de la instancia de origen [SWS_CORE_00342]. En una asignación por movimiento, la instancia de destino renuncia a su estado compartido previo y asume el estado del objeto transferido de forma análoga a una operación de intercambio [SWS_CORE_00343]. Además, el método swap permite intercambiar el estado interno con otra instancia [SWS_CORE_00352]. Al destruirse mediante el destructor, se libera o se abandona un estado compartido que aún se retenga [SWS_CORE_00349]. Mientras que el constructor predeterminado está diseñado para ser seguro para hilos [SWS_CORE_00341], las operaciones de movimiento, las asignaciones, el intercambio (swap) y la destrucción no son seguros para hilos ([SWS_CORE_00342], [SWS_CORE_00343], [SWS_CORE_00352], [SWS_CORE_00349]).

Diagrama de estados: ciclo de vida y transiciones de estado del estado compartido en una instancia de Promise. Fuentes: [SWS_CORE_00341], [SWS_CORE_00342], [SWS_CORE_00343], [SWS_CORE_00344], [SWS_CORE_00345], [SWS_CORE_00349], [SWS_CORE_00353], [SWS_CORE_00355]

Ruta de uso

Un flujo típico de provisión comprende los siguientes pasos:

1. Creación: el productor instancia un ara::core::Promise<T, E> [SWS_CORE_00341].
2. Recuperar Future: antes de iniciar el procesamiento asíncrono, el productor llama a get_future() [SWS_CORE_00344]. Dado que por cada Promise solo se permite un único Future asociado, esta llamada debe realizarse exactamente una vez. El Future devuelto se transfiere al hilo consumidor.
3. Establecer resultado: tras concluir la operación asíncrona, el productor transfiere el resultado al estado compartido y sitúa a este en el estado ready. Para ello dispone de sobrecargas seguras para hilos tanto para operaciones de copia como de movimiento:
   • Valor correcto: llamada a set_value ([SWS_CORE_00345], [SWS_CORE_00346]).
   • Estado de error: llamada a SetError ([SWS_CORE_00353], [SWS_CORE_00354]).
   • Resultado combinado: llamada a SetResult ([SWS_CORE_00355], [SWS_CORE_00356]).

Diagrama de secuencia: secuencia de llamadas y sincronización entre productor, Promise, Shared State y consumidor. Fuentes: [SWS_CORE_00341], [SWS_CORE_00344], [SWS_CORE_00345], [SWS_CORE_00353], [SWS_CORE_00355]

Escenarios de error

La especificación define precondiciones estrictas para todas las interacciones con el estado compartido, cuyo incumplimiento conduce a violaciones estandarizadas (Violations):

• Recuperación múltiple del Future: si se llama a get_future() más de una vez para el mismo estado compartido, se produce la violación IsoStdFutureErrcFutureAlreadyRetrievedViolation [SWS_CORE_00344].
• Ausencia de Shared State: si la instancia llamada no posee un estado compartido —por ejemplo, tras realizar una operación de movimiento—, get_future() da lugar a IsoStdFutureErrcNoStateViolation [SWS_CORE_00344]. En este caso, los métodos set_value, SetError y SetResult desencadenan la violación PromiseNoSharedStateToSetViolation ([SWS_CORE_00345], [SWS_CORE_00353], [SWS_CORE_00355]).
• Estado ya satisfecho: si el estado compartido ya ha sido asignado con un valor, error o resultado, cualquier llamada sucesiva a set_value ([SWS_CORE_00345], [SWS_CORE_00346]), SetError ([SWS_CORE_00353], [SWS_CORE_00354]) o SetResult ([SWS_CORE_00355], [SWS_CORE_00356]) provoca la violación IsoStdFutureErrcPromiseAlreadySatisfiedViolation.
• Seguridad ante excepciones: los métodos set_value, SetError y SetResult ofrecen seguridad condicional ante excepciones (conditionally exception safe). No lanzan excepciones, siempre que los constructores de los tipos T y E estén declarados como nothrow ([SWS_CORE_00345], [SWS_CORE_00353], [SWS_CORE_00355]).

Interpretación: el abandono del estado compartido durante la destrucción de la instancia sin una asignación previa de valor ([SWS_CORE_00349]) debería conllevar, de forma análoga al comportamiento estándar de C++ de std::promise, que un Future asociado registre el correspondiente evento de error al intentar la lectura. Pregunta Q-fd013bb17a591af9 (abierta)