classe ara::shwa::TaskHandler

La classe ara::shwa::TaskHandler sert à l’exécution de tâches sur du matériel d’accélération via des soumissions en file d’attente [AP_SWS_SHWA_01203]. Les nouvelles instances sont créées de manière thread-safe via la méthode fabrique statique Create(), qui renvoie les erreurs dans le ara::core::Result [AP_SWS_SHWA_01202]. Via SingleTask ainsi que ParallelFor, des étapes de calcul individuelles ou à parallélisme de données peuvent être transmises au périphérique cible. Tandis que l’instanciation est thread-safe, les soumissions de tâches ne le sont pas et nécessitent une synchronisation externe en cas d’accès parallèle.

plus ›

Contexte

En tant que classe finale (final), la classe ara::shwa::TaskHandler fait partie du module pour l’accélération matérielle (shwa) au sein d’AUTOSAR Adaptive Platform. Elle fait office d’interface centrale pour la transmission et l’exécution de tâches de calcul sur un périphérique cible sélectionné (Device). Au sein de l’architecture logicielle, la classe assume le rôle d’intermédiaire entre le composant logiciel applicatif et l’infrastructure d’exécution sous-jacente.

L’interaction a lieu principalement entre deux partenaires du système : l’application appelante et l’accélérateur matériel sélectionné ou sa file d’attente de tâches. Les opérations de calcul définies côté application sont réceptionnées via les interfaces de ara::shwa::TaskHandler et transmises au périphérique sous forme de soumissions en file d’attente [AP_SWS_SHWA_01203]. Cela permet aussi bien le traitement d’étapes de calcul individuelles que de modèles de traitement à parallélisme de données [AP_SWS_SHWA_01204]. Interprétation : la classe devrait encapsuler les files d’attente spécifiques au périphérique, de sorte que les composants applicatifs puissent piloter les ressources d’accélération sans être liés à des détails matériels de bas niveau. Question (ouverte)

Cycle de vie

Le cycle de vie d’une instance de ara::shwa::TaskHandler est contrôlé par un patron de conception fabrique strict. L’instanciation s’effectue exclusivement via la méthode fabrique statique Create() [AP_SWS_SHWA_01202]. La classe étant déclarée comme final, une spécialisation par héritage est exclue. L’objet créé est renvoyé encapsulé dans un ara::core::Result<TaskHandler>, ce qui impose de vérifier explicitement le succès de l’initialisation [AP_SWS_SHWA_01202].

En matière de concurrence et de sécurité des threads, la classe présente des caractéristiques différenciées :

• Instanciation : l’appel de la méthode statique Create() est thread-safe (thread-safe) [AP_SWS_SHWA_01202]. Plusieurs threads peuvent ainsi créer simultanément de nouvelles instances de gestionnaires via le chemin de la fabrique.
• Soumission de tâches : les méthodes de transmission des ordres de travail, SingleTask [AP_SWS_SHWA_01203] et ParallelFor [AP_SWS_SHWA_01204], sont explicitement spécifiées comme non thread-safe (not thread-safe). Une instance unique de TaskHandler ne doit par conséquent pas être sollicitée simultanément depuis plusieurs threads de manière non coordonnée ; la synchronisation incombe à l’appelant.
• Sécurité face aux exceptions : toutes les méthodes de l’interface sont déclarées comme noexcept et garantissent la sécurité face aux exceptions (exception safe) [AP_SWS_SHWA_01202], [AP_SWS_SHWA_01203], [AP_SWS_SHWA_01204]. Pour Create(), des sémantiques de rollback s’appliquent en outre (rollback_semantics) si l’initialisation échoue [AP_SWS_SHWA_01202].

La propriété demeure auprès du composant applicatif, qui détient l’instance et la détruit dès qu’aucune soumission supplémentaire en file d’attente n’est requise.

Parcours d'utilisation

Le déroulement typique s’articule autour des phases de création, de configuration des ordres et de transmission des tâches. Dans un premier temps, l’application demande une nouvelle instance via ara::shwa::TaskHandler::Create() [AP_SWS_SHWA_01202]. Après validation réussie du ara::core::Result, l’objet est prêt à recevoir des ordres de travail.

Ensuite, l’application décide de la méthode de transmission appropriée en fonction du modèle de traitement :

• Pour les tâches de calcul individuelles, SingleTask(cfg) est appelée, ce qui met en file d’attente la fonction de tâche passée en paramètre dans le périphérique cible sélectionné [AP_SWS_SHWA_01203].
• Pour les modèles de traitement à parallélisme de données, le modèle de fonction ParallelFor(bufferSize, cfg) est disponible [AP_SWS_SHWA_01204]. En plus de la configuration, la taille de tampon (bufferSize) est également transmise afin de piloter l’exécution parallèle sur plusieurs éléments de données au sein du périphérique accélérateur.

Interprétation : le paramètre de modèle T devrait représenter ici une fonction appelable, une lambda ou une configuration de tâche correspondante encapsulant la logique de calcul à exécuter sur le périphérique. Question Q-2fca8604440b44e9 (ouverte)

Diagramme de séquence : chaîne d’interaction depuis l’instanciation jusqu’à la soumission de tâches dans la file d’attente du périphérique. Sources : [AP_SWS_SHWA_01202], [AP_SWS_SHWA_01203], [AP_SWS_SHWA_01204]

Scénarios d'erreur

Le traitement des erreurs dans ara::shwa::TaskHandler suit le paradigme exempt d’exceptions (noexcept) de l’Adaptive Platform.

Les états d’erreur surviennent principalement lors de l’instanciation :

• La méthode fabrique Create() signale les échecs via le canal d’erreur dans la valeur de retour ara::core::Result [AP_SWS_SHWA_01202].
• L’identifiant d’erreur concret défini est ShwaErrorCode::kRuntime, qui signale des erreurs générales d’exécution lors de la création de l’objet [AP_SWS_SHWA_01202]. Grâce aux sémantiques de rollback spécifiées, il est garanti qu’aucun état partiellement initialisé ni aucune fuite de ressources n’apparaissent en cas d’échec [AP_SWS_SHWA_01202].

Les appels SingleTask [AP_SWS_SHWA_01203] et ParallelFor [AP_SWS_SHWA_01204] ne renvoient aucune valeur de retour (void) et ne déclenchent aucune exception. Les appelants doivent donc s’assurer que l’instance du gestionnaire est valide et que les accès lors de threads concurrents sont synchronisés de manière externe.