module ara::core — Adaptive Platform Core

Le module core fournit les types de base à l'échelle de la plateforme, les pools de mémoire PMR et les primitives de synchronisation asynchrones Future et Promise pour l'AUTOSAR Adaptive Platform (SWArchitecture p. 60, [SWS_CORE_00326]). Pour satisfaire aux exigences strictes de sécurité et de temps réel, le type somme Result<T, E> remplace les exceptions classiques par des valeurs de retour déterministes ([SWS_CORE_00751]). En cas d'erreurs système irréparables, la fonction fail-fast Abort() garantit l'interruption immédiate et contrôlée du processus ([SWS_CORE_00052]).

plus ›

Le module core fait office de cluster fonctionnel de base de l'AUTOSAR Adaptive Platform et fournit des structures de données uniformes, des primitives de communication asynchrones et des mécanismes de gestion de la mémoire pour tous les services de plateforme et applications (SWArchitecture p. 60). Afin de garantir des déroulements déterministes et la sécurité fonctionnelle dans les environnements de système d'exploitation POSIX, core remplace les exceptions C++ conventionnelles par le type de résultat à sûreté de typage Result<T, E> et contrôle les allocations de mémoire dynamique via des allocateurs polymorphes ([SWS_CORE_00041], [SWS_CORE_00751]).

Diagramme de contexte : intégration du cluster fonctionnel ara::core et de ses domaines d'interface dans l'Adaptive Platform. Sources : SWArchitecture p. 60, SWArchitecture p. 36

Pour la synchronisation concurrente, core implémente l'interaction de Future et Promise ([SWS_CORE_00326], [SWS_CORE_00344]). Tandis que le producteur fournit l'état de calcul ou l'erreur via le Promise, Future permet au consommateur aussi bien des interrogations avec temporisation via wait_for() que des retransmissions réactives au moyen de then() ([SWS_CORE_00329], [SWS_CORE_00331], TimeSynchronization p. 90).

Diagramme d'activité : chemin d'évaluation déterministe d'un objet Result dans le cas sans erreur et en cas d'erreur. Sources : [SWS_CORE_00751], [SWS_CORE_00755], [SWS_CORE_00757], [SWS_CORE_00766]

Afin d'éviter la fragmentation, le module met à disposition des ressources de pool telles que SynchronizedPoolResource et UnsynchronizedPoolResource, qui limitent les allocations à des blocs de taille fixe ([SWS_CORE_00030], [SWS_CORE_00067], SWArchitecture p. 61). Si un état d'erreur insurmontable survient, la plateforme force via Abort(), sous réserve de l'exécution préalable d'un AbortHandler enregistré, la terminaison immédiate fail-fast du processus ([SWS_CORE_00051], [SWS_CORE_00052]).

plus ›

Rôle système et base architecturale d'ara::core

Le module core constitue le socle fondamental de l'AUTOSAR Adaptive Platform et fournit les définitions de types élémentaires, les mécanismes de gestion de la mémoire ainsi que les interfaces de base pour tous les clusters fonctionnels et Adaptive Applications (SWArchitecture p. 60). Contrairement aux services spécifiques à l'application, core est conçu pour être local au processus et définit les abstractions essentielles pour réaliser des logiciels C++ portables, déterministes et efficaces en ressources au sein d'environnements de système d'exploitation POSIX (SWArchitecture p. 36).

Sur le plan architectural, le module sert d'interface standardisée entre les fonctions du système d'exploitation proches du matériel et les couches supérieures de l'Adaptive Platform (SWArchitecture p. 60). À cet égard, core répond aux exigences centrales de sécurité fonctionnelle (ASIL) et de capacité temps réel en rendant contrôlables les allocations dynamiques de mémoire et en renonçant à l'utilisation systématique des exceptions C++ dans le flux de contrôle standard ([SWS_CORE_00052], [SWS_CORE_00751]). La mise à disposition de types de base à l'échelle de la plateforme évite les solutions isolées propriétaires entre composants middleware tels que ara::com ou ara::ts (ARAComAPI p. 46, TimeSynchronization p. 90).

Diagramme de contexte : intégration du cluster fonctionnel ara::core et de ses domaines d'interface dans l'Adaptive Platform. Sources : SWArchitecture p. 60, SWArchitecture p. 36

Flux de contrôle et de données asynchrones via Future et Promise

Pour une interaction concurrente et découplée, ara::core implémente le patron producteur-consommateur au moyen de Promise et Future ([SWS_CORE_00326], [SWS_CORE_00341]). Un Promise représente l'interface d'écriture via laquelle un worker asynchrone ou un squelette de communication dépose le résultat ou une erreur ([SWS_CORE_00345], [SWS_CORE_00353]). La contrepartie consommatrice est constituée par Future, qui surveille l'état partagé (Shared State) et encapsule l'accès à sûreté de typage à la valeur de retour (ARAComAPI p. 46, ARAComAPI p. 59).

Afin d'éviter le blocage des threads clients, Future propose, outre la fonction d'interrogation synchrone et bloquante get() ([SWS_CORE_00326]), des opérations d'attente à durée limitée : wait_for() et wait_until() renvoient un indicateur d'état de type FutureStatus ([SWS_CORE_00329], [SWS_CORE_00330], ARAComAPI p. 1). Via la méthode then(), il est possible d'enregistrer des callbacks qui sont automatiquement exécutés à l'arrivée du résultat ; il est possible d'y intégrer au choix un Executor spécifique à l'utilisateur pour diriger l'exécution vers des pools de threads déterminés ([SWS_CORE_00024], [SWS_CORE_00331], [SWS_CORE_00337]). Les opérations de copie sont explicitement interdites pour Future et Promise afin de garantir des relations de propriété exclusives ([SWS_CORE_00334], [SWS_CORE_00350]).

Diagramme de séquence : transmission asynchrone de valeurs et d'erreurs entre le worker et l'application via Promise et Future. Sources : [SWS_CORE_00326], [SWS_CORE_00329], [SWS_CORE_00344], [SWS_CORE_00345], TimeSynchronization p. 90

Gestion déterministe des erreurs : Result, ErrorCode et ErrorDomain

Un aspect fondamental de la programmation orientée sécurité dans l'Adaptive Platform est l'évitement strict des exceptions non contrôlées en fonctionnement normal. ara::core::Result<T, E> sert d'encapsulation de type somme à sûreté de typage qui contient soit une valeur de charge utile de succès de type T, soit un objet d'erreur de type E ([SWS_CORE_00721], [SWS_CORE_00723], [SWS_CORE_00751]). Des spécialisations existent aussi bien pour les types de référence Result<T&, E> que pour les opérations sans valeur de retour Result<void, E> ([SWS_CORE_00821], [SWS_CORE_00908]).

L'état contenu est vérifié via HasValue() ou l'opérateur de conversion explicite operator bool() ([SWS_CORE_00751], [SWS_CORE_00752]). L'accès aux données utiles s'effectue via Value() ou operator*(), tandis que les erreurs sont interrogées via Error() ([SWS_CORE_00755], [SWS_CORE_00757]). Pour le traitement fonctionnel ultérieur et la propagation des erreurs, Result fournit des méthodes telles que Bind(), ValueOr() et Resolve() ([SWS_CORE_00761], [SWS_CORE_00768]). Les erreurs sont modélisées via ErrorCode, qui associe un code d'erreur numérique CodeType à un identifiant de domaine unique ErrorDomain ainsi qu'à des données supplémentaires de diagnostic optionnelles SupportDataType ([SWS_CORE_00121], [SWS_CORE_00122], [SWS_CORE_00512]). La méthode ValueOrThrow() sert de passerelle pour les environnements avec gestion des exceptions activée, mais lève en cas d'erreur l'exception associée au domaine ([SWS_CORE_00154], [SWS_CORE_00766]).

Diagramme d'activité : chemin d'évaluation déterministe d'un objet Result dans le cas sans erreur et en cas d'erreur. Sources : [SWS_CORE_00751], [SWS_CORE_00755], [SWS_CORE_00757], [SWS_CORE_00766]

Gestion polymorphe de la mémoire via des ressources de pool

L'allocation dynamique sur le tas standard comporte des risques de non-déterminisme et de fragmentation de la mémoire. ara::core intègre donc une gestion de la mémoire basée sur des ressources de mémoire polymorphes (PMR), inspirée du patron C++ NVI (Non-Virtual Interface) (SWArchitecture p. 61). La classe de base MemoryResource déclare les interfaces publiques allocate() et deallocate(), qui pilotent en interne les méthodes purement virtuelles do_allocate() et do_deallocate() ([SWS_CORE_00041], [SWS_CORE_00061]).

Pour les modèles d'allocation critiques pour le temps réel, des ressources de pool spécialisées sont disponibles : SynchronizedPoolResource offre des allocations thread-safe à partir de tronçons et de tailles de blocs préconfigurés via PoolOptions ([SWS_CORE_00027], [SWS_CORE_00030]). Pour les phases de traitement strictement locales au thread sans surcoût de synchronisation, UnsynchronizedPoolResource est utilisé ([SWS_CORE_00046], [SWS_CORE_00067]). Via release(), l'ensemble de la zone de mémoire allouée peut être restitué en une seule étape à la upstream_resource() située en amont, ce qui empêche efficacement les fuites de mémoire dans les flux de travail orientés phases ([SWS_CORE_00037], [SWS_CORE_00038], [SWS_CORE_00065]).

Diagramme de classes : hiérarchie des ressources de mémoire polymorphes selon le patron Non-Virtual Interface (NVI). Sources : SWArchitecture p. 61, [SWS_CORE_00030], [SWS_CORE_00041], [SWS_CORE_00061]

Types utilitaires et conteneurs fondamentaux (Optional, Array, Vector, Map)

Pour éviter tout comportement indéfini et garantir une sémantique claire, core standardise des conteneurs et des types d'assistance élémentaires. ara::core::Optional<T> représente des valeurs pouvant être présentes ou non, sans devoir recourir à des pointeurs nuls non sécurisés ([SWS_CORE_01103], [SWS_CORE_01104], ARAComAPI p. 1). L'état est interrogé via has_value() ou operator bool(), tandis que les accès s'effectuent via value(), value_or() ou operator*() ([SWS_CORE_01128], [SWS_CORE_01129], [SWS_CORE_01130], [SWS_CORE_01134]). Des surcharges de référence spécifiques Optional<T&> permettent de conserver en toute sécurité des références optionnelles ([SWS_CORE_01151], [SWS_CORE_01167]).

Pour les structures de données à taille fixe, le module fournit Array<T, N>, qui prend en charge l'indexation directe via operator[], l'accès avec vérification des bornes au moyen de at() ainsi que des itérateurs standard ([SWS_CORE_01250], [SWS_CORE_01265], [SWS_CORE_01273]). Les opérateurs de comparaison sont implémentés conformément à des règles de codage strictes avec des retours bool et la sécurité vis-à-vis des exceptions ([SWS_CORE_01290], CPP14Guidelines p. 241). Les séquences à croissance dynamique et les conteneurs associatifs sont couverts par Vector<T, Allocator> et Map<Key, T, Compare, Allocator> ([SWS_CORE_01318], [SWS_CORE_01428]). Les deux types acceptent des allocateurs configurables, de sorte que les allocations peuvent être traitées de manière transparente via les pools polymorphes MemoryResource ([SWS_CORE_00066], [SWS_CORE_01303], [SWS_CORE_01406]).

Comportement en cas d'erreur et terminaison Fail-Fast

Si un processus ne peut pas compenser de manière sûre un état d'erreur critique, le principe Fail-Fast de l'Adaptive Platform s'applique (SWArchitecture p. 60). L'interface Abort() provoque la terminaison immédiate et inconditionnelle du processus en cours d'exécution ([SWS_CORE_00052]). La fonction est déclarée comme [[noreturn]] et noexcept afin de garantir qu'aucune routine de déroulement de pile ni aucun destructeur ne génère d'états consécutifs incorrects ([SWS_CORE_00052], SWArchitecture p. 36).

Afin de sauvegarder des informations de diagnostic volatiles ou d'exécuter d'ultimes actions de journalisation d'urgence avant l'arrêt, les applications peuvent enregistrer des fonctions de rappel spécifiques à l'utilisateur via SetAbortHandler() ou AddAbortHandler() ([SWS_CORE_00050], [SWS_CORE_00051], [SWS_CORE_00054]). Un gestionnaire d'interruption enregistré doit respecter la signature void() noexcept ([SWS_CORE_00053]). Après l'exécution du gestionnaire, la plateforme impose l'arrêt définitif du processus, de sorte qu'aucune poursuite de l'exécution dans un état de mémoire indéfini n'est possible (SWArchitecture p. 60).

Diagramme d'activité : flux de contrôle de l'interruption Fail-Fast via Abort() avec exécution de l'AbortHandler. Sources : SWArchitecture p. 60, [SWS_CORE_00051], [SWS_CORE_00052]

Preuves détaillées supplémentaires

La spécification de core dans la release R25-11 repose sur un ensemble de stipulations normatives et de modèles architecturaux. Pour le cycle de vie des processus et le comportement d'arrêt d'urgence, Initialize(), Deinitialize() ainsi que Abort() et SetAbortHandler() sont constitutifs ([SWS_CORE_00051], [SWS_CORE_00052], SWArchitecture p. 60). Le modèle de communication asynchrone repose principalement sur Future ([SWS_CORE_00326], [SWS_CORE_00329]) et Promise ([SWS_CORE_00344], [SWS_CORE_00345]), dont l'interaction est vérifiée dans des clusters proches des applications tels que ara::com et ara::ts (ARAComAPI p. 46, TimeSynchronization p. 90).

La gestion irréprochable des données et de la mémoire est normée par les spécifications relatives à Result ([SWS_CORE_00751], [SWS_CORE_00766]), ErrorCode ([SWS_CORE_00512]) et aux classes de mémoire PMR SynchronizedPoolResource ainsi que UnsynchronizedPoolResource ([SWS_CORE_00030], [SWS_CORE_00046], SWArchitecture p. 61). De plus, des directives relatives aux conteneurs et aux comparaisons définissent la conservation déterministe des données dans des systèmes complets critiques pour la sécurité ([SWS_CORE_01103], [SWS_CORE_01250], [SWS_CORE_01318], CPP14Guidelines p. 241).