Publications internationales

• Dataflow Language for Signal Processing Modeling with Parallel Implementations Issues - VIII European Signal Processing Conference (EUSIPCO'96), EURASIP, September 1996 - G. de Wailly, F. Boéri
  This paper describes λ-Flow, a new functional synchronous dataflow language for DSP applications. It is independent of the handled data. It plainly supports the modular design. Its sound semantics allows proofs of programs and time/memory determinisms. The target code is dynamically loaded into the compiler with a target description that is defined with less than twenty lines of definitions. Due to the static feature of the solving model, it is possible to implement programs onto a static parallel architecture.


• A Graphical Interface for the Functional Synchronous Dataflow Language Lambda-flow - Dynamic Object Workshop (DOW'96), Object World East, may 1996 - G. de Wailly.
  In this paper a graphical interface for a functional synchronous data-flow language is described.
  The intent of this work is to show how a dynamic object-oriented language can be used to model complex and realistic "things" in a very short time.
  The object paradigm allows a homogeneous view of objects with common methods. An inheritance mechanism significantly reduces the code because of the feature sharing.
  Here, the classical database object-model shows the relationships between object instances. In addition, the inheritance-graph describes the inner construct of objects. The program is specified with small-talk.
  The graphical toolkit is simulated with a root class, so the code can be adapted to numerous object oriented languages, because the graphical aspects are not a part of the model. Particularly, in this paper, we use GNU small-talk without any graphical possibilities. In our final version of the graphical interface, we use the STK language that offers a graphical interface with TK, and an object oriented layer with Clos.


• A CAD Tool Chain for Signal Processing Applications, with Parallel Implementations Issues - Groningen Information Technology Conference (GRONIC'96), February 1996 - G. de Wailly, F. Boéri.
  In this paper, a CAD tool chain is globally presented. These tools allow graphical descriptions of signal processing applications to be implemented in a specific parallel architectures, via several transformation steps.
  The user interfaces of this tool chain is a graphical editor and a syntactic language, both based on a semantic functional synchronous data flow formalism. They allow a modular design of application.
  This CAD tool chain is built upon an accurate semantic data flow language named λ-matrix. The language is independent with the user's algebra: it is "a thing that handles things". Several criterion functions are defined to determine some properties such as time and memory determinisms.
  Λ-matrices can be compiled for several targets. Programs are firstly flattened with a functional operator that keeps the semantics. Then a sequencer produces the code, according to the selected target.
  Due to the particular solving method which allows parallelism exploitation, we have defined a cheap parallel architecture built with common controllers.


• A Parallel Architecture Simulator for the Lambda-matrices - Association of Lisp Users Meeting and Workshop Proceedings (LUV'95), August 1995 - G. de Wailly, F. Boéri.
  In this paper, a software simulator of a parallel multiprocessor architecture is described. The intent of this work is to show how a dynamic object-oriented language can be used to model complex and realistic "things" in a very short time. The object paradigm allows an homogeneous view of objects with common methods. An inheritance mechanism significantly reduces the code because of the feature sharing. Here, the classical database object-model shows the relationships between object instances. In addition, the inheritance-graph describe the inner construct of objects. A graphical interface is built over the simulator, but only its layout is shown here.


• Specification of a Functional Synchronous Dataflow Language for Parallel Implementation with the Denotational Semantics - Symposium on Applied Computing (SAC'96), February 1996 - G. de Wailly, F. Boéri.
  In this paper, a semantic description of an abstract language using a functional synchronous data-flow (FSDF) paradigm is defined. This work is intended to implement signal processing applications in parallel architectures. This language is as simple as possible.
  Some properties are defined, such as time and memory determinisms. In order to establish these properties, criterion functions are established. Relations between properties and criterion functions are proven (these proofs are not in this paper).
  Systems are solved with a fully functional abstract machine which allows a great parallelism exploitation. Parallel accesses to the common memory can be statically shared among processors. It results in a cheap and simple parallel architecture without any conflicts management.

rapports internes

• Modélisation fonctionnelle et graphique des applications à états en vue de leur réalisation sur architectures parallèles statiques. - Master Thesis, january 1996 - G de Wailly.
  L'accroissement incessant des performances des micro-processeurs donne à ces circuits électroniques une complexité telle qu'il est impossible d'en garantir la sécurité de fonctionnement. Le modèle des processeurs n'a pas changé depuis sa création : il est bâti sur une architecture de von-Neumann, typiquement séquentielle.
  Le parallélisme semble être une solution pour augmenter, à priori facilement, les performances des architectures matérielles. Il existe principalement deux sortes de parallélisme : le parallélisme à grain fin, ou parallélisme d'instructions, et le parallélisme à gros grain, ou parallélisme de tâches. Ce dernier concerne plutôt la répartition de processus sur un réseau d'ordinateurs et il ne joue aucun rôle dans l'augmentation des performances des processeurs.
  
  Le parallélisme à grain fin, dont on espère beaucoup pour augmenter les performances des micro-processeurs semble en partie inefficace. D'une part, les architectures massivement parallèles sont difficiles à programmer efficacement d'une manière automatique et d'autre part, les temps de communication des architectures basées sur des réseaux d'inter-connections sont prohibitifs par rapport aux temps d'exécution des instructions utiles.
  Nous proposons dans notre thèse un modèle d'architecture parallèle appelée architecture parallèle statique. Il s'agit d'une architecture construite à l'aide de processeurs communs, de type contrôleur ou DSP, partageant une mémoire globale. Son originalité est d'annuler les temps de communication entre les processeurs et la mémoire, puisque les processeurs sont directement connectés au bus, via un circuit d'interface à logique trois états.
  Cette architecture n'est utilisable que si les conflits d'accès à la mémoire globale sont résolus au moment de la compilation des applications. Son exploitation dépend donc fortement des outils de développement associés.
  Les outils développés durant la thèse, baptisés \LambdaOutils, permettent une programmation graphique et hiérarchique des applications, une programmation à l'aide d'un langage de haut niveau, leur exécution sur le simulateur de l'architecture parallèle statique.
  
  D'une manière informelle, toute application modélisable à l'aide d'un graphe ou d'un schéma de boîtes peut être programmée avec cette chaîne d'outils. Ainsi toute application reposant sur un modèle à état est-elle programmable, ce qui couvre en particulier les filtres numériques et les circuits électroniques numériques.


• A formal compiler for the Lambda-matrices - Rapport de Recherche, septembre 1996 - G de Wailly.
  Last year, the λ-matrices language is introduced to the SAC'96 conference. It is a functional synchronous data-flow language which can model state based applications. The formalism includes the language, the functional abstract solving machine and the criterion functions.
  In this paper, a formal compiler of the λ-matrices is implemented. The type checking is not mentioned here because it uses a traditional method. The heart of the compiler is the linearizer which suppresses the module structure of the source programs in order to obtain a flattened program.
  The final code production becomes easy due to the simplicity of the flattened code. The functional dependencies between the micro-tasks can be easily deduced, so a static parallelism exploitation is possible.


• Lambda-flow - version 0.3.1 - Rapport de Recherche, juillet 1996 - G de Wailly, F Boéri.
  This document presents the lambda-flow language and its compiler. This is a functional synchronous data-flow language.
  lambda-flow can model every application that can be described with a graph and that does not contain any fix-point definition. A graphical interface is proposed and it is currently rewriting with the Motif tool-kit.
  The advantage of lambda-flow is its simplicity for the final user and its adaptability. lambda-flow does not contain complicated construction, which are difficult to learn, and with a confuse semantics (or a semantics that is difficult to understand).
  
  The language has the minimal set of objects to model graph based application in a modular way. A module can be separately compiled. lambda-flow encourages polymorphic module definition in order to have a maximal code reuse.
  It is a strongly typed language, but the type checking is as transparent as possible. It is not necessary to declare everywhere the type of the handled data: the compiler uses a powerful method to deduce these types from the data.
  The language is extremely adaptable to any purpose because the handled data and their operators are not specified in the language. They form algebra that are text files dynamically loaded into the compiler. The only mandatory algebra is the integer algebra. Of course, the user can easily write an algebra and use mixed algebra in the same program.
  In an other hand, lambda-flow is adaptable because the target code is not statically specified into the compiler: the target code definition is a text file dynamically loaded. The standard distribution issues three target code definitions for C, Scheme and i386 assembler. The user can easily add a target code.
  
  lambda-flow was originated to allow signal processing application to be implemented onto parallel architecture. The underlined architecture is static because the language guarantees that all the memory accesses are known at compile-time. This is possible because lambda-flowprograms are deterministic in time and in resources.


• Lambda-graph - version 0.1  - Rapport de Recherche, juillet 1995 - G de Wailly, F Boéri.
  


• Lambda-matrices: modélisation et simulation algébrique et fonctionnelle des modèles d'états - Rapport de Recherche, avril 1995 - G de Wailly, F Boéri.
  Dans ce rapport interne, nous présentons ici un formalisme algébrique et fonctionnel destiné à la description et à la résolution des systèmes basés sur un modèle d'état, et plus particulièrement, des systèmes de traitement du signal. Ce modèle original est proche du concept des graphes DATA-FLOW et permet une représentation graphique des applications. Construit à l'aide de l'algèbre linéaire et du λ-calcul, proche de la sémantique dénotationnelle, il autorise la conception modulaire d'un système, la connaissance de ses caractéristiques "complétude", "calculabilité", "stabilité", "mesurabilité" et sa résolution déterministe. L'implantation dans une architecture matérielle peut exploiter le parallélisme mis en évidence de manière naturelle.


• Implémentation des lambda-matrices à l'aide du lambda-calcul - Rapport de Recherche, mars 1995 - G de Wailly, F Boéri.
  Dans ce rapport interne, il est montré comment réaliser un interprète de λ-matrices à l'aide de λ-expressions. Les &lambda-matrices sont un language abstrait (sémantique) orienté Data Flow Synchrone et Fonctionnel. Il permet de modéliser les applications de traitements du signal en vue de leur réalisation sur une architecture matérielle parallèle.
  Ce rapport a pour seul objectif de montrer que cette réalisation est possible, et donc que les λ-matrices sont fonctionnelles.


• Projet de recherche Lambda-X - Rapport de DEA, juillet 1993 - G de Wailly.


• Projet de recherche Lambda-X: L'interprète SCHEME GSM - Rapport de DEA, juillet 1993 - G de Wailly.