Sheep in wolf's clothing: Implementation models for data-flow multi-threaded software
Brebis déguisées en loups : Modèles d’implémentation pour systèmes parallèles flots de données
Résumé
Concurrent programming is notoriously difficult, especially in
constrained embedded contexts. Threads, in particular, are wildly
nondeterministic as a model of computation, and difficult to analyze
in the general case. Fortunately, it is often the case that
multi-threaded, semaphore-synchronized embedded software implements
high-level functional specifications written in a deterministic
data-flow language such as Scade or (safe subsets of) Simulink.
We claim that in this case the implementation process should build
not just the multi-threaded C code, but (first and foremost) a
richer model exposing the dataflow organization of the computations
performed by the implementation. From this model, the C code is
extracted through selective pretty-printing, while knowledge of the
data-flow organization facilitates analysis.
We propose a language for describing such implementation models that
expose the data-flow behavior (the sheep) hiding under the form of a
multi-threaded program (the wolf). The language allows the representation of
efficient implementations featuring pipelined scheduling and
optimized memory allocation and synchronization. We show
applicability on a large-scale industrial avionics case study and
on a commercial many-core.
La programmation concurrente est une discipline difficile, particulièrement dans un contexte de systèmes embarqués. Les threads, en particulier, sont un modèle de calcul non-déterministe et difficile à analyser dans le cas général. Heureusement, les logiciels embarqués
multi-threadés synchronisés par sémaphores sont souvent des implémentations de spécifications fonctionnelles de haut niveau écrites dans un langage flot-de-données déterministe comme Scade ou (un sous-ensemble sûr de) Simulink. Dans ce cas, le processus d’implémentation devrait, non seulement construire le code C multi-threadé de l’implémentation, mais avant tout un modèle plus riche exposant l’organisation du flot-de-données des calculs effectués par le code. De ce modèle, le code C peut être extrait par du simple pretty printing. En même temps, la structure flot-de-donnée facilite l’analyse. Nous proposons un langage pour la description de tels modèles d’implémentations qui exposent le comportement flot-de-donnée (la brebis) déguisé en un programme multi-threadé (le loup). Ce langage permet une représentation d’implémentations efficaces avec ordonnancement pipeliné et allocation mémoire et synchronisations optimisées. Nous montrons son application sur un cas d’étude de l’industrie aéronautique et sur une plateforme many-coeurs commerciale
Origine | Fichiers produits par l'(les) auteur(s) |
---|
Loading...