módulo ara::core — Adaptive Platform Core

El módulo core proporciona los tipos básicos de toda la plataforma, pools de memoria PMR y primitivas de sincronización asíncronas Future y Promise para la AUTOSAR Adaptive Platform (SWArchitecture p. 60, [SWS_CORE_00326]). Para cumplir los estrictos requisitos de seguridad y tiempo real, el tipo suma Result<T, E> sustituye las excepciones clásicas por valores de retorno deterministas ([SWS_CORE_00751]). En caso de errores irreparables del sistema, la función de fail-fast Abort() garantiza la interrupción inmediata y controlada del proceso ([SWS_CORE_00052]).

más ›

El módulo core actúa como cluster funcional básico de la AUTOSAR Adaptive Platform y proporciona estructuras de datos uniformes, primitivas de comunicación asíncrona y mecanismos de gestión de memoria para todos los servicios de plataforma y aplicaciones (SWArchitecture p. 60). Para garantizar ejecuciones deterministas y seguridad funcional en entornos de sistemas operativos POSIX, core sustituye las excepciones convencionales de C++ por el tipo de resultado con seguridad de tipos Result<T, E> y controla las asignaciones de memoria dinámica a través de asignadores polimórficos ([SWS_CORE_00041], [SWS_CORE_00751]).

Diagrama de contexto: integración del cluster funcional ara::core y sus áreas de interfaz en la Adaptive Platform. Fuentes: SWArchitecture p. 60, SWArchitecture p. 36

Para la sincronización concurrente, core implementa la interacción de Future y Promise ([SWS_CORE_00326], [SWS_CORE_00344]). Mientras el productor proporciona el estado de cálculo o el error a través del Promise, Future permite al consumidor tanto consultas con control de tiempo mediante wait_for() como reenvíos reactivos mediante then() ([SWS_CORE_00329], [SWS_CORE_00331], TimeSynchronization p. 90).

Diagrama de actividad: ruta de evaluación determinista de un objeto Result en caso sin errores y en caso de error. Fuentes: [SWS_CORE_00751], [SWS_CORE_00755], [SWS_CORE_00757], [SWS_CORE_00766]

Para evitar la fragmentación, el módulo proporciona recursos de pool como SynchronizedPoolResource y UnsynchronizedPoolResource, que limitan las asignaciones a fragmentos (chunks) de tamaño fijo ([SWS_CORE_00030], [SWS_CORE_00067], SWArchitecture p. 61). Si se produce un estado de error insuperable, la plataforma fuerza a través de Abort(), con ejecución previa de un AbortHandler registrado, la terminación inmediata del proceso por fail-fast ([SWS_CORE_00051], [SWS_CORE_00052]).

más ›

Rol en el sistema y base arquitectónica de ara::core

El módulo core constituye los cimientos fundamentales de la AUTOSAR Adaptive Platform y proporciona definiciones de tipos básicas, mecanismos de gestión de memoria e interfaces base para todos los clusters funcionales y Adaptive Applications (SWArchitecture p. 60). A diferencia de los servicios específicos de la aplicación, core está diseñado de forma local al proceso y define las abstracciones esenciales para realizar software en C++ portable, determinista y eficiente en recursos dentro de entornos de sistemas operativos POSIX (SWArchitecture p. 36).

Arquitectónicamente, el módulo actúa como una interfaz estandarizada entre las funciones del sistema operativo cercanas al hardware y las capas superiores de la Adaptive Platform (SWArchitecture p. 60). Al hacer esto, core aborda requisitos centrales de seguridad funcional (ASIL) y capacidad de tiempo real, haciendo controlables las asignaciones de memoria dinámica y prescindiendo del uso generalizado de excepciones de C++ en el flujo de control regular ([SWS_CORE_00052], [SWS_CORE_00751]). La provisión de tipos básicos en toda la plataforma evita soluciones aisladas propietarias entre componentes de middleware como ara::com o ara::ts (ARAComAPI p. 46, TimeSynchronization p. 90).

Diagrama de contexto: integración del cluster funcional ara::core y sus áreas de interfaz en la Adaptive Platform. Fuentes: SWArchitecture p. 60, SWArchitecture p. 36

Flujos asíncronos de control y de datos a través de Future y Promise

Para la interacción concurrente y desacoplada, ara::core implementa el patrón productor-consumidor mediante Promise y Future ([SWS_CORE_00326], [SWS_CORE_00341]). Un Promise representa la interfaz de escritura a través de la cual un worker asíncrono o un skeleton de comunicación deposita el resultado o un error ([SWS_CORE_00345], [SWS_CORE_00353]). La contraparte consumidora está formada por Future, que monitoriza el estado compartido (Shared State) y encapsula el acceso con seguridad de tipos al valor de retorno (ARAComAPI p. 46, ARAComAPI p. 59).

Para evitar el bloqueo de subprocesos cliente, Future proporciona, junto a la función de consulta síncrona y bloqueante get() ([SWS_CORE_00326]), operaciones de espera con límite de tiempo: wait_for() y wait_until() devuelven un indicador de estado de tipo FutureStatus ([SWS_CORE_00329], [SWS_CORE_00330], ARAComAPI p. 1). A través del método then() se pueden registrar callbacks que se ejecutan automáticamente al recibir el resultado; de forma opcional, se puede integrar un Executor específico del usuario para dirigir la ejecución a determinados pools de subprocesos ([SWS_CORE_00024], [SWS_CORE_00331], [SWS_CORE_00337]). Las operaciones de copia están explícitamente deshabilitadas para Future y Promise con el fin de garantizar una propiedad exclusiva ([SWS_CORE_00334], [SWS_CORE_00350]).

Diagrama de secuencia: Transferencia asíncrona de valores y errores entre el worker y la aplicación a través de Promise y Future. Fuentes: [SWS_CORE_00326], [SWS_CORE_00329], [SWS_CORE_00344], [SWS_CORE_00345], TimeSynchronization p. 90

Gestión determinista de errores: Result, ErrorCode y ErrorDomain

Un aspecto central de la programación orientada a la seguridad en la Adaptive Platform es la estricta prevención de excepciones no controladas en el funcionamiento regular. ara::core::Result<T, E> actúa como una encapsulación de tipo suma con seguridad de tipos que contiene o bien un valor de carga útil de éxito de tipo T o bien un objeto de error de tipo E ([SWS_CORE_00721], [SWS_CORE_00723], [SWS_CORE_00751]). Existen especializaciones tanto para tipos de referencia Result<T&, E> como para operaciones sin valor de retorno Result<void, E> ([SWS_CORE_00821], [SWS_CORE_00908]).

El estado contenido se comprueba mediante HasValue() o el operador de conversión explícito operator bool() ([SWS_CORE_00751], [SWS_CORE_00752]). El acceso a los datos útiles se realiza a través de Value() o operator*(), mientras que los errores se consultan mediante Error() ([SWS_CORE_00755], [SWS_CORE_00757]). Para el procesamiento funcional posterior y la propagación de errores, Result proporciona métodos como Bind(), ValueOr() y Resolve() ([SWS_CORE_00761], [SWS_CORE_00768]). Los errores se modelan mediante ErrorCode, que vincula un código de error numérico CodeType con un identificador de dominio unívoco ErrorDomain, así como datos adicionales de diagnóstico opcionales SupportDataType ([SWS_CORE_00121], [SWS_CORE_00122], [SWS_CORE_00512]). El método ValueOrThrow() existe como puente para entornos con gestión de excepciones habilitada, pero en caso de error desencadena la excepción asociada al dominio ([SWS_CORE_00154], [SWS_CORE_00766]).

Diagrama de actividad: ruta de evaluación determinista de un objeto Result en caso sin errores y en caso de error. Fuentes: [SWS_CORE_00751], [SWS_CORE_00755], [SWS_CORE_00757], [SWS_CORE_00766]

Gestión de memoria polimórfica mediante recursos de pool

La asignación dinámica en el heap estándar entraña riesgos respecto al no determinismo y la fragmentación de la memoria. Por ello, ara::core integra una gestión de memoria basada en recursos de memoria polimórficos (PMR), inspirada en el patrón NVI (Non-Virtual Interface) de C++ (SWArchitecture p. 61). La clase base MemoryResource declara las interfaces públicas allocate() y deallocate(), que internamente invocan los métodos puramente virtuales do_allocate() y do_deallocate() ([SWS_CORE_00041], [SWS_CORE_00061]).

Para patrones de asignación críticos en tiempo real se dispone de recursos de pool especializados: SynchronizedPoolResource ofrece asignaciones seguras para subprocesos a partir de chunks y tamaños de bloque preconfigurados mediante PoolOptions ([SWS_CORE_00027], [SWS_CORE_00030]). Para fases de procesamiento estrictamente locales al subproceso sin sobrecarga de sincronización sirve UnsynchronizedPoolResource ([SWS_CORE_00046], [SWS_CORE_00067]). Mediante release(), todo el rango de memoria asignado se puede devolver en un único paso al upstream_resource() previo, lo que previene eficazmente las fugas de memoria en flujos de trabajo orientados a fases ([SWS_CORE_00037], [SWS_CORE_00038], [SWS_CORE_00065]).

Diagrama de clases: Jerarquía de los recursos de memoria polimórficos según el patrón Non-Virtual Interface (NVI). Fuentes: SWArchitecture p. 61, [SWS_CORE_00030], [SWS_CORE_00041], [SWS_CORE_00061]

Tipos fundamentales de utilidad y contenedores (Optional, Array, Vector, Map)

Para evitar comportamientos indefinidos y garantizar una semántica clara, core estandariza contenedores y tipos auxiliares elementales. ara::core::Optional<T> representa valores que pueden estar presentes o no, sin necesidad de recurrir a punteros nulos inseguros ([SWS_CORE_01103], [SWS_CORE_01104], ARAComAPI p. 1). El estado se consulta mediante has_value() o operator bool(), mientras que los accesos se realizan mediante value(), value_or() o operator*() ([SWS_CORE_01128], [SWS_CORE_01129], [SWS_CORE_01130], [SWS_CORE_01134]). Sobrecargas de referencia especiales Optional<T&> permiten mantener referencias opcionales de forma segura ([SWS_CORE_01151], [SWS_CORE_01167]).

Para estructuras de datos de tamaño fijo, el módulo proporciona Array<T, N>, que admite indexación directa mediante operator[], acceso con comprobación de límites mediante at() e iteradores estándar ([SWS_CORE_01250], [SWS_CORE_01265], [SWS_CORE_01273]). Los operadores de comparación están implementados de acuerdo con estrictas directrices de codificación con retornos de tipo bool y seguridad frente a excepciones ([SWS_CORE_01290], CPP14Guidelines p. 241). Las secuencias de crecimiento dinámico y los contenedores asociativos quedan cubiertos por Vector<T, Allocator> y Map<Key, T, Compare, Allocator> ([SWS_CORE_01318], [SWS_CORE_01428]). Ambos tipos aceptan asignadores configurables, de modo que las asignaciones pueden gestionarse sin fisuras mediante los pools polimórficos de MemoryResource ([SWS_CORE_00066], [SWS_CORE_01303], [SWS_CORE_01406]).

Comportamiento en caso de error y terminación Fail-Fast

Si un proceso no puede compensar de forma segura un estado de error grave, interviene el principio fail-fast de la Adaptive Platform (SWArchitecture p. 60). A través de la interfaz Abort() se induce la terminación inmediata e incondicional del proceso en ejecución ([SWS_CORE_00052]). La función está declarada como [[noreturn]] y noexcept para garantizar que ninguna rutina de desenrollado de pila ni destructor genere estados subsiguientes incorrectos ([SWS_CORE_00052], SWArchitecture p. 36).

Para asegurar información de diagnóstico volátil o ejecutar últimas acciones de registro de emergencia antes de la finalización, las aplicaciones pueden registrar funciones de retrollamada específicas del usuario a través de SetAbortHandler() o AddAbortHandler() ([SWS_CORE_00050], [SWS_CORE_00051], [SWS_CORE_00054]). Un manejador de aborto registrado debe cumplir la signatura void() noexcept ([SWS_CORE_00053]). Tras la ejecución del manejador, la plataforma fuerza la terminación definitiva del proceso, de modo que no es posible continuar la ejecución en un estado de memoria indefinido (SWArchitecture p. 60).

Diagrama de actividades: Flujo de control de la interrupción fail-fast mediante Abort() con ejecución del AbortHandler. Fuentes: SWArchitecture p. 60, [SWS_CORE_00051], [SWS_CORE_00052]

Más evidencia detallada

La especificación de core en la versión R25-11 se basa en una serie de disposiciones normativas y modelos arquitectónicos. Para el ciclo de vida del proceso y el comportamiento de parada de emergencia son constitutivos Initialize(), Deinitialize(), así como Abort() y SetAbortHandler() ([SWS_CORE_00051], [SWS_CORE_00052], SWArchitecture p. 60). El modelo de comunicación asíncrona se apoya de forma determinante en Future ([SWS_CORE_00326], [SWS_CORE_00329]) y Promise ([SWS_CORE_00344], [SWS_CORE_00345]), cuya interacción se verifica en clusters cercanos a la aplicación como ara::com y ara::ts (ARAComAPI p. 46, TimeSynchronization p. 90).

La gestión de memoria y datos sin fallos queda normalizada por las especificaciones relativas a Result ([SWS_CORE_00751], [SWS_CORE_00766]), ErrorCode ([SWS_CORE_00512]) y las clases de memoria PMR SynchronizedPoolResource y UnsynchronizedPoolResource ([SWS_CORE_00030], [SWS_CORE_00046], SWArchitecture p. 61). De manera complementaria, las directrices de contenedores y comparación definen la retención determinista de datos en sistemas globales críticos para la seguridad ([SWS_CORE_01103], [SWS_CORE_01250], [SWS_CORE_01318], CPP14Guidelines p. 241).