Soit P un programme bien typ´e et R0, H∅, E∅, avec R0 = h∅, ∅i`n | . . . | h∅, ∅i`n | P
t0, le syst`eme
initial associ´e. Par d´efinition d’un programme bien typ´e et en notant que acc(P) = ∅ et Dom(H∅) = ∅,
on a BR0, H∅, E∅ et R0, H∅, E∅est bien form´e. On montre que le programme est compatible avec les
droits d’acc´es. Soit S0,S1, . . .une ex´ecution du programme et soit i ≥ 0. Supposons que Si−−−→
(t,ro)
Si+1.
Par induction sur la longueur de la d´erivation S0,S1, . . . ,Si, d’apr`es les lemmes 2 et 3, il est imm´ediat
que Si est bien form´e et qu’il existe Γ tel que Γ B Si. On doit montrer que soit o = t, soit o = ` pour
` ∈ Loc et t est actif en `. La preuve est par cas sur la r`egle utilis´ee pour la r´eduction. En particulier, il est suffisant de montrer le r´esultat pour les r´eductions de la forme Si −−→
M Si+1 telles que M , ∅.
On peut donc supposer que la r´eduction est une instance de la r`egle (context1) (le cas (context2) est
similaire). En particulier, Si = Ri, Hi, Ei et Si+1 = Ri+1, Hi+1, Ei+1 o`u Ri ≡ hE[P]t · T, T0i` | R01 et
Ri+1≡ hE[P0]t· T, T0i`| R01avec `t,` P, H , E −−−→
(t,ro)
P0, H0, E0, on proc`ede par cas sur la r`egle utilis´ee pour la r´eduction.
– Supposons que la r`egle est une instance de la r`egle (get), i.e. P = (x = get e) · P00 et P0 =
P00[v/x] o`u e ⇓ ro et v = H (ro). Par d´efinition de la s´emantique, on a E[P] ` et donc
Γ B P : E avec E ≤ access(`) par le lemme 7. En particulier, soit o = ` (r`egle (GET2)) soit
o est un nom de thread (r`egle (GET2)). Si o est un nom de thread alors o = t puisque, par
hypoth`ese, {ro} ⊆ acc(e) ⊆ acc(E[P]) ⊆ Re ft.
– Si la r`egle utilis´ee est une instance d’une des r`egles (re f1), (re f2) et (set), le raisonnement est
Chapitre 11
Conclusion
Dans ce manuscript, nous nous sommes int´eress´e `a deux propri´et´es des langages de programma- tion de la famille des langages r´eactifs. De mani`ere g´en´erale, la v´erification de ces deux propri´et´es, essentielles aux langages consid´er´es, ´etait jusqu’ici de la responsabilit´e du programmeur. A travers une analyse de la s´emantique des mod`eles de programmation sous-jacents, nous avons propos´e des d´efinitions formelles de ces propri´et´es et des outils d’analyse statique qui permettent de garantir que celles-ci sont v´erifi´ees par les programmes.
Dans la premi`ere partie de ce document, nous avons ´etudi´e la question de la r´eactivit´e des pro- grammes pour un sous-ensemble du π-calcul synchrone. Plus pr ´ecis´ement, nous avons propos´e une propri´et´e, la r´eactivit´e efficace, qui assure que, `a chaque instant, la taille du programme et le nombre d’´etapes de calcul sont polyn ˆomiales en la taille initiale du programme et en la taille des entr´ees du syst`eme. Nous avons ´egalement propos´e une analyse statique qui garantit qu’un programme est r´eactif efficace. Cette analyse statique repose sur la g´en´eration de contraintes permettant, lorsque celles-ci sont interpr´et´ees dans une structure adapt´ee, de prouver la terminaison des instants et de contr ˆoler la taille du syst`eme. En particulier, cette analyse repose sur des techniques emprunt ´ees aux syst`emes de r´e´ecriture (preuves de terminaison) et sur une adaptation des quasi-interpr ´etations `a notre mod`ele (en particulier par la mise en oeuvre d’une orientation des flots de donn ´ees).
Les r´esultats pr´esent´es ici concernent un sous-ensemble du π-calcul synchrone ; la cr ´eation dyna- mique de threads est interdite et le nombre de lectures pouvant ˆetre r´ealis´ees par un thread au cours d’un mˆeme cycle est limit´e. Par la suite, nous esp´erons d´epasser ces deux restrictions. D’une part, dans le cadre des contraintes portant sur la taille du syst`eme, nous pourrions envisager de consid´erer une interpr´etation additive de la composition parall`ele. Par exemple, si un appel `a A peut g´en´erer deux appels `a B, A devrait contr ˆoler la somme des deux appels et non pas contr ˆoler individuellement chaque appel comme cela et le cas actuellement. D’autre part, il nous semble maintenant que l’int ´erˆet de la condition read-once est purement technique ; celle-ci permet uniquement de simplifier les raisonne- ments. Nous essaierons donc par la suite d’adapter les r´esultats de mani`ere `a ce que nous puissions nous passer de cette restriction.
En partant de ces am´eliorations, nous esp´erons pouvoir r´ealiser une implantation exp´erimentale du mod`ele de calcul et de l’analyse statique correspondante. La synth`ese des types, et en particulier des r´egions associ´ees au signaux ne semble pas poser de probl`eme. La difficult´e principale r´eside dans la synth`ese des quasi-interpr´etations. De ce point de vue, on peut noter que les contraintes g ´en´er´ees par notre analyse statique sont similaires `a celles consid´er´es dans le cadre des langages fonctionnels du premier ordre. En particulier, il sera donc possible d’utiliser les outils d ´evelopp´es dans ce cadre ; l’uti- lisation des quasi-interpr´etations multi-lin´eaires sur l’alg`ebre max-plus repr´esenterait une premi`ere
110 CHAPITRE 11. CONCLUSION ´
etape int´eressante permettant de consid´erer des syst`emes non-size-increasing.
Une autre piste de recherche int´eressante pour la suite de ce travail concerne le probl`eme de la caract´erisation de l’expressivit´e de l’analyse statique propos´ee. De ce point, les fonctions continues sur les flots calcul´ees par les r´eseaux de Kahn[66] constituent un bon point de d´epart. Quelles fonctions continues sont calculables par les programmes r´eactifs efficaces du π-calcul synchrone. Par exemple, la fonction qui `a chaque instant ´emet sur un signal la liste des valeurs ´emises sur un autre signal depuis le d´ebut du calcul est clairement continue mais n’est pas expressible par un programme r ´eactif efficace (ce calcul suppose une m´emoire non born´ee). Pour cette ´etude, il sera int´eressant de consid´erer un sous ensemble d´eterministe du π-calcul synchrone.
Dans la seconde partie de ce document, nous avons pr´esent´e le langage qui nous a permis de mieux ´etudier l’utilisation du style de programmation introduit par les , i.e. le m ´elange des styles coop´eratif et pr´eemptif, dans le cadre des architectures modernes `a base de plusieurs unit´es de calcul concurrentes. Comme nous l’avons vu, ce mod`ele de programmation cherche `a d´epasser les limitations d’une approche purement coop´erative en plongeant celle-ci dans un sur-ensemble per- mettant de b´en´eficier de certains des avantages d’une programmation bas´ee sur un ordonnancement pr´eemptif. Nous avons vu que la librairie des ne parvient pas totalement `a atteindre ce but ; en particulier, l’atomicit´e de l’ex´ecution du code plac´e entre deux points de coop´eration d’une thread n’est pas garantie. Par rapport aux travaux existants nous avons apport ´e : (1) la d´efinition d’une s´emantique formelle de ce style de programmation dans le cadre d’un langage du premier ordre, (2) la d´efinition d’une discipline de programmation permettant d’atteindre le but mentionn ´e ci-dessus et une analyse statique permettant de garantir le respect de cette derni `ere.
Par la suite, nous envisageons d’approfondir l’´etude du paradigme de programmation propos´e par
. Certaines exp´erimentations nous conduisent `a penser qu’il serait int´eressant de s´eparer l’aspect
synchronisation (partage des instants et de la visibilit´e des signaux) de l’aspect partage de la m´emoire. Nous envisageons de distinguer au sein de chaque zone synchrone plusieurs zones m ´emoires, par- tag´ees par des groupes distincts de threads. De cette mani`ere, il serait possible pour des threads de se synchroniser, i.e. de partager les instants et de communiquer par signaux valu ´es, tout en b´en´eficiant d’une ex´ecution parall`ele (actuellement, un thread ne peut b´en´eficier de ces deux possibilit´es simul- tan´ement). Un tel mod`ele pourrait ˆetre vu comme une construction sur trois niveaux correspondants `a diff´erentes utilisations de l’architecture : (1) les threads libres : utilisation de plusieurs cores, (2) les zones synchrones : utilisation de plusieurs cores synchronis´es et (3) les threads partageant la m´emoire : s´equentialisation de l’ex´ecution. On peut noter ici que le nouveau niveau envisag´e (le niveau 2) cor- respond au mod`ele de programmation propos´e par le S π-calcul. Il nous semble ´egalement qu’il serait int´eressant de consid´erer ce mod`ele de programmation ind´ependamment de l’aspect contr ˆole des res- sources. Pour cela nous envisageons de r´ealiser une impl´ementation du futur langage au dessus d’un langage tel qu’O C afin de proposer une alternative aux threads utilis ´es dans ce dernier. Dans cette nouvelle version du langage, nous essaierons ´egalement de consid´erer la possibilit´e de cr´eer dynamiquement de nouvelles zones synchrones.
Pour conclure, nous pouvons noter la r´ealisation, par F. Boussinot, d’un langage exp´erimental, appel´e [1], bas´e sur les d´eveloppements de ce manuscript. Le choix d’un noyau fonctionnel du premier ordre pour le langage d´ecoule de la volont´e de combiner, au moins partiellement, les m´ethodes d´evelopp´ees ici au sein de ce langage. Le langage est tr`es proche du langage et permet, en particulier, la programmation d’architectures multi-cores. Cette impl ´ementation comporte un algorithme d’inf´erence (non encore formalis´e) pour un syst`eme de types proche de celui de . Les r´esultats de la partie I, portant sur le π-calcul synchrone, sont ´egalement utilis´es en partie dans
. L’analyse statique mise en oeuvre, qui ne repose pas sur les quasi-interpr ´etations, assure
111 sur la taille du syst`eme et sur les temps de r´eaction existent mais ne sont pas mises en ´evidence par celle-ci. Cette restriction permet toutefois de garantir : (1) que les r´eactions terminent toujours et (2) l’absence de fuite m´emoire. Malgr`es ces restrictions, l’expressivit´e du langage reste raisonnable comme le montrent les exemples propos´es[1].
Bibliographie
[1] The fun loft web page : http ://www-sop.inria.fr/mimosa/rp/funloft/index.html.
[2] Raul Acosta-Bermejo. Reactive operating system, reactive java objects. In Proceedings of NO-
TERE’2000, 2000.
[3] Roberto M. Amadio. Max-plus quasi-interpretations. In Proceedings of Typed Lambda Calculi
and Applications, volume 2701 of Lecture Notes in Computer Science. Springer-Verlag, 2003.
[4] Roberto M. Amadio. The synchronous language, revisited. Journal of Logic and Algebraic
Programming, 70 :121–150, 2005.
[5] Roberto M. Amadio. Synthesis of max-plus quasi-interpretations. Fundamenta Informaticae, 65(1-2) :29 :60, 2005.
[6] Roberto M. Amadio. A synchronous pi-calculus. Technical Report hal-00078319, Universit ´e Paris 7, Laboratoire PPS, 2006.
[7] Roberto M. Amadio, G´erard Boudol, Fr´ed´eric Boussinot, and Illaria Castellani. Reactive pro- gramming, revisited. Electronic Notes in TCS, 162 :49–90, 2005.
[8] Roberto M. Amadio, Solange Coupet-Grimal, Silvano Dal-Zilio, and Line Jakubiec. A functio- nal scenario for bytecode verification of resource bounds. In Proceedings of CSL 2004, Lecture Notes in Computer Science. Springer-Verlag, 2004.
[9] Roberto M. Amadio and Fr´ed´eric Dabrowski. Feasible reactivity for synchronous cooperative threads. Electronic Notes in TCS, 154 :3 :33–43, 2005.
[10] Roberto M. Amadio and Silvano Dal Zilio. Resource control for synchronous cooperative threads. Theoretical Computer Science, 358 :229–254, 2004.
[11] David Aspinall, Stephen Gilmore, Martin Hofmann, Donald Sannella, and Ian Stark. Mobile resource guarantees for smart devices. In Construction and Analysis of Safe, Secure and In-
teroperable Smart Devices : Proceedings of the International Workshop CASSIS 2004, number
3362 in Lecture Notes in Computer Science, page 1–26. Springer-Verlag, 2005.
[12] Franz Baader and Tobias Nipkow. Term rewriting and all that. Cambridge University Press, New York, NY, USA, 1998.
[13] Stephen Bellantoni and Stephen Cook. A new recursion-theoretic characterization of the poly- time functions (extended abstract). In STOC ’92 : Proceedings of the twenty-fourth annual ACM
symposium on Theory of computing, page 283–293, New York, NY, USA, 1992. ACM Press.
[14] Albert Benveniste and G´erard Berry. The synchronous approach to reactive and real-time systems. Another Look at Real Time Programming, Proceedings of the IEEE, Special Issue, 79(9) :1270–1282, 1991.
114 BIBLIOGRAPHIE [15] Albert Benveniste, Paul Caspi, Stephen A. Edwards, Nicolas Halbwachs, Paul Le Guernic, and Robert De Simone. The synchronous languages 12 years later. Proceedings of the IEEE, 91(1), January 2003.
[16] G´erard Berry and Georges Gonthier. The Esterel synchronous programming language : Design, semantics, implementation. Science of Computer Programming, 19(2) :87–152, 1992.
[17] Andrew D. Birrell. An introduction to programming with threads. Technical Report 35, Digital Systems Research Center, Palo Alto, California, 1989.
[18] Guillaume Bonfante, Adam Cichon, Jean-Yves Marion, and H ´el`ene Touzet. Complexity classes and rewrite systems with polynomial interpretation. In CSL, page 372–384, 1998.
[19] Guillaume Bonfante, Jean-Yves Marion, and Jean-Yves Moyen. On lexicographic termination ordering with space bound certifications. In Dines Bjørner, Manfred Broy, and Alexandre V. Zamulin, editors, Perspectives of System Informatics, 4th International Andrei Ershov Memorial
Conference, PSI 2001, Novosibirsk, Russia, volume 2244 of Lecture Notes in Computer Science.
Springer, Jul 2001.
[20] Guillaume Bonfante, Jean-Yves Marion, and Jean-Yves Moyen. Quasi-interpretations, a way to control resources. Theoretical Computer Science, (en r´evision).
[21] G´erard Boudol. ULM : A core programming model for global computing. In Proceedings of the
13th European Symposium on Programming, ESOP’04, volume 2986 of LNCS. Springer-Verlag,
2004.
[22] Fr´ed´eric Boussinot. Reactive c : an extension of c to program reactive systems. Softw. Pract.
Exper., 21(4) :401–428, 1991.
[23] Fr´ed´eric Boussinot. Icobj programming. Technical Report 3028, INRIA, 1996. [24] Fr´ed´eric Boussinot. Java fair threads. Technical Report RR-4139, INRIA, 2002.
[25] Fr´ed´eric Boussinot. Operational semantics of cooperative fair threads, unpublished, 2002. [26] Fr´ed´eric Boussinot. Fairthreads : mixing cooperative and preemptive threads in C. Concurr.
Comput. : Pract. Exper., 18(5) :445–469, 2006.
[27] Fr´ed´eric Boussinot and Robert De Simone. The synchronous language. IEEE Trans. on
Software Engineering, 22(4) :256–266, 1996.
[28] Fr´ed´eric Boussinot, Laurent Hazard, and Jean-Ferdy Susini. The junior reactive kernel. Techni- cal Report 3732, INRIA, 1999.
[29] Fr´ed´eric Boussinot and Jean-Ferdy Susini. The sugarcubes tool box. Technical Report 3247, INRIA, 1997.
[30] Chandrasekhar Boyapati, Robert Lee, and Martin Rinard. Ownership types for safe program- ming : preventing data races and deadlocks. In OOPSLA ’02 : Proceedings of the 17th ACM
SIGPLAN conference on Object-oriented programming, systems, languages, and applications,
page 211–230, New York, NY, USA, 2002. ACM Press.
[31] Chandrasekhar Boyapati and Martin Rinard. A parameterized type system for race-free Java programs. In 16th Annual Conference on Object-Oriented Programming, Systems, Languages,
and Applications (OOPSLA), Tampa Bay, FL, 2001.
[32] Christian Brunette. Construction et simulation graphiques de comportements : le mod`ele des
BIBLIOGRAPHIE 115 [33] Paul Caspi and Marc Pouzet. Synchronous kahn networks. In International Conference on
Functional Programming, page 226–238, 1996.
[34] Emmanuel Chailloux, Pascal Manoury, and Bruno Pagano. Developing Applications With Ob-
jective Caml. O’Reilly France, 2000.
[35] Jong-Deok Choi, Keunwoo Lee, Alexey Loginov, Robert O’Callahan, Vivek Sarkar, and Manu Sridharan. Efficient and precise datarace detection for multithreaded object-oriented programs. In PLDI ’02 : Proceedings of the ACM SIGPLAN 2002 Conference on Programming language
design and implementation, page 258–269, New York, NY, USA, 2002. ACM Press.
[36] Adam Cichon. Bounds on derivation lengths from termination proofs. Technical Report CSD- TR-622, Department of Computer Science, University of London, 1990.
[37] Alan Cobham. The intrinsic computational difficulty of functions. In Y. Bar-Hillel, editor, Logic,
Methodology, and Philosophy of Science, page 24–30. North-Holland, 1964.
[38] The crocus web page : http ://libresource.inria.fr//projects/crocus.
[39] Nachum Dershowitz. Orderings for term-rewriting systems. Theoretical Computer Science, 17(3) :279–301, 1982.
[40] Nachum Dershowitz and Jean-Pierre Jouannaud. Rewrite systems. In Handbook of Theoretical
Computer Science, Volume B : Formal Models and Sematics (B), page 243–320. MIT Press,
1990.
[41] Nachum Dershowitz and Zohar Manna. Proving termination with multiset orderings. Commun.
ACM, 22(8) :465–476, 1979.
[42] Edsger W. Dijkstra. Cooperating sequential processes. page 65–138, 2002.
[43] St´ephane Epardaud. Mobile reactive programming in ULM. In 2004 Scheme Workshop, Sep- tember 2004.
[44] Cormac Flanagan and Martin Abadi. Types for safe locking. In ESOP ’99 : Proceedings of the
8th European Symposium on Programming Languages and Systems, page 91–108, London, UK,
1999. Springer-Verlag.
[45] Cormac Flanagan and Stephen N. Freund. Type-based race detection for java. In PLDI ’00 :
Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and im- plementation, page 219–232, New York, NY, USA, 2000. ACM Press.
[46] Cormac Flanagan and Stephen N Freund. Atomizer : a dynamic atomicity checker for multi- threaded programs. In POPL ’04 : Proceedings of the 31st ACM SIGPLAN-SIGACT symposium
on Principles of programming languages, page 256–267, New York, NY, USA, 2004. ACM
Press.
[47] Cormac Flanagan and Shaz Qadeer. A type and effect system for atomicity, 2003.
[48] Cormac Flanagan and Shaz Qadeer. Types for atomicity. In TLDI ’03 : Proceedings of the 2003
ACM SIGPLAN international workshop on Types in languages design and implementation, page
1–12, New York, NY, USA, 2003. ACM Press.
[49] Georges Gonthier. S´emantique et mod`eles d’ex´ecution des langages r´eactifs synchrones : appli-
cations `a Esterel. PhD thesis, Universit´e d’Orsay, 1988.
[50] Nicolas Halbwachs. Synchronous programming of reactive systems. Kluwer Academic Pub., 1993.
116 BIBLIOGRAPHIE [51] Nicolas Halbwachs, Paul Caspi, Pascal Raymond, and Daniel Pilaud. The synchronous data- flow programming language LUSTRE. Another Look at Real Time Programming, Proceedings
of the IEEE, Special Issue, 79(9) :1305–1320, 1991.
[52] Kevin Hammond. An abstract machine for resource-bounded computations in hume. In Draft
paper submitted to IFL ’03 ˘2014 Implementation of Functional Languages, Edinburgh, Scotland,
2003.
[53] Kevin Hammond and Greg Michaelson. The design of hume : a high-level language for the real-time embedded systems domain. In TOCHECK, 2003.
[54] Kevin Hammond and Greg Michaelson. Hume : a domain-specific language for real-time em- bedded systems. In Proc. Conf. Generative Programming and Component Engineering. Lecture Notes in Computer Science, Springer-Verlag, 2003.
[55] Lance Hammond, Brian D. Carlstrom, Vicky Wong, Ben Hertzberg, Mike Chen, Christos Ko- zyrakis, and Kunle Olukotun. Programming with transactional coherence and consistency (tcc).
SIGOPS Oper. Syst. Rev., 38(5) :1–13, 2004.
[56] Th´er`ese Hardin. Produire un logiciel de confiance : quelles hypoth`eses, quelles limites ? In
Journ´ees Francophones des Langages Applicatifs, 2002.
[57] David Harel and Amir Pnueli. On the development of reactive systems. In Logics and Models of
Concurrent Systems, NATO Advanced Summer Institutes, volume F-13, page 477–498. Springer-
Verlag, 1985.
[58] Tim Harris and Keir Fraser. Language support for lightweight transactions. In OOPSLA ’03 :
Proceedings of the 18th annual ACM SIGPLAN conference on Object-oriented programing, sys- tems, languages, and applications, page 388–402, New York, NY, USA, 2003. ACM Press.
[59] C. A. R. Hoare. Monitors : an operating system structuring concept. Commun. ACM,
17(10) :549–557, October 1974.
[60] Dieter Hofbauer. Termination proofs by multiset path orderings imply primitive recursive deri- vation lengths. Theor. Comput. Sci., 105(1) :129–140, 1992.
[61] Martin Hofmann. A type system for bounded space and functional in-place update. Nordic J. of
Computing, 7(4) :258–289, 2000.
[62] Martin Hofmann. The strength of non-size increasing computation. In POPL ’02 : Proceedings
of the 29th ACM SIGPLAN-SIGACT symposium on Principles of programming languages, page
260–269. ACM Press, 2002.
[63] John Ousterhout. Why threads are a bad idea (for most purposes) - http ://www.sunlabs.com/ ous- ter/, 1996.
[64] Pierre Jouvelot and David Gifford. Algebraic reconstruction of types and effects. In Conference
Record of the Eighteenth Annual ACM Symposium on Principles of Programming Languages, Orlando, Florida, page 303–310. ACM Press, 1991.
[65] The MRG group web page : http ://groups.inf.ed.ac.uk/mrg/.
[66] Gilles Kahn. The semantics of a simple language for parallel programming. In Information
Processing, volume 74. North-Holland, 1974.
[67] Sam Kamin and Jean-Jacques L´evy. Attempts for generalizing the recursive path orderings. Rapport technique, Universit´e de l’Illinois, Urbana, 1980.
BIBLIOGRAPHIE 117 [68] Jan Willem Klop. Term rewriting systems. In Handbook of Logic in Computer Science, Volumes
1 (Background : M athematical Structures) and 2 (Background : Computational Structures), Abramsky & Gabbay & Maibaum (Eds.), Clarendon, volume 2. Cambridge University Press,
1992.
[69] D.S. Landford. On proving term rewriting systems are noetheriens. Technical Report MTP-3, Louisiana Technical University, 1979.
[70] Paul Le Guernic, Thierry Gautier, Michel Le Borgne, and Claude Le Maire. Programming real time applications with signal. Proc. IEEE, Special Issue, 79 :1321–1336, 1991.
[71] Chin Soon Lee, Neil D. Jones, and Amir M. Ben-Amram. The size-change principle for program termination. ACM SIGPLAN Notices, 36(3) :81–92, 2001.
[72] Daniel Leivant. A foundational delineation of computational feasibility. In lics91, page 2–11, 1991.
[73] Louis Mandel. Conception, S´emantique et Implantation de ReactiveML : un langage `a la ML
pour la programmation r´eactive. PhD thesis, Universit´e Paris 6, 2006.
[74] Louis Mandel and Farid Benbadis. Simulation of mobile ad hoc network protocols in Reacti- veML. In Synchronous Languages, Applications and Programming (SLAP’05). ENTCS, 2005.