Ctrl-A is motivated by today's context where computing systems, large (data centers) or small (embedded), are more and more required to be adaptive to the dynamical fluctuations of their environments and workloads, evolutions of their computing infrastructures (shared, or subject to faults), or changes in application functionalities. Their administration, traditionally managed by human system administrators, needs to be automated in order to be efficient, safe and responsive. Autonomic Computing is the approach that emerged in the early 2000's in distributed systems to answer that challenge, in the form of self-administration control loops. They address objectives like self-configuration (e.g. in service-oriented systems), self-optimization (resource consumption management e.g., energy), self-healing (fault-tolerance, resilience), self-protection (security and privacy).
Therefore, there is a pressing and increasing demand for methods and tools to design controllers for self-adaptive computing systems, that ensure quality and safety of the behavior of the controlled system. The critical importance of the quality of control on performance and safety in automated systems, in computing as elsewhere, calls for a departure from traditional approaches relying on ad hoc techniques, often empirical, unsafe and application-specific solutions.
The main objective of the Ctrl-A project-team is to develop a novel framework for model-based design of controllers in Autonomic Computing. We want to contribute generic Software Engineering methods and tools for developers to design appropriate controllers for their particular reconfigurable architectures, software or hardware, and integrate them at middleware level. We want to improve concrete usability of techniques from Control Theory, particularly Discrete Event Systems, by specialists of concrete systems (rather than formal models) , and to provide tool support for our methods in the form of specification languages and compilers. We address policies for self-configuration, self-optimization (resource management, low power), self-healing (fault tolerance) and self-protection (security).
The main objective of Ctrl-A translates into a number of scientific challenges, the most important of these are:
(i) programming language support, on the two facets of model-oriented languages, based on automata , and of domain specific languages, following e.g., a component-based approach , or related to rule-based or HMI languages ;
(ii) design methods for reconfiguration controller design in computing systems, proposing generic systems architectures and models based on transition systems , , classical continuous control or controlled stochastic systems.
We adopt a strategy of constant experimental identification of needs and validation of proposals, in application domains like middleware platforms for Cloud systems , multi-core HPC architectures , Dynamic Partial Reconfiguration in FPGA-based hardware and the IoT and smart environments .
Achieving the goals of Ctrl-A requires multidisciplinarity and expertise from several domains. The expertise in Autonomic Computing and programming languages is covered internally by members of the Ctrl-A team. On the side of theoretical aspects of control, we have active external collaborations with researchers specialized in Control Theory, in the domain of Discrete Event Systems as well as in classical, continuous control. Additionally, an important requirement for our research to have impact is to have access to concrete, real-world computing systems requiring reconfiguration control. We target autonomic computing at different scales, in embedded systems or in cloud infrastructures, which are traditionally different domains. This is addressed by external collaborations, with experts in either hardware or software platforms, who are generally missing our competences on model-based control of reconfigurations.
We are attacking the problem of designing well-regulated and efficient self-adaptive computing systems by the development of novel strategies for systems management.
The kind of systems we typically target involve relatively coarse grained computation tasks (e.g. image processing or HPC tasks, components or services), assembled in workflows, application dependency graphs, or composites. At that level, there can be parallel and conditional branches, as well as choices that can be made between alternative branches, corresponding to different ways to perform that part of the application. Such tasks can be achieved following a choice of implementations or versions, such as in service oriented approaches. Each implementation has its own characteristics and requirements, e.g., w.r.t. resources consumed and QoS offered. The systems execution infrastructures present heterogeneity, with different computing processors, a variety of peripheral devices (e.g., I/O, video port, accelerators), and different means of communications. This hardware or middleware level also presents adaptation potential e.g., in varying quantities of resources or sleep and stand-by modes.
The kinds of control problems encountered in these adaptive systems concern the navigation in the configurations space defined by choice points at the levels of applications, tasks, and architecture. Upon events or conditions triggering reconfiguration and adaptation, the controller has to choose a next configuration where, on the one hand, all consistency constraints are satisfied w.r.t. dependencies and resources requirements. On the other hand, it has to apply a policy or strategy deciding between correct configurations which one to chose e.g. by optimizing one or more criteria, or by insuring reachability of some later configuration (goal or fallback). This targeted class of computing systems we consider is mid-sized, in the sense that the combinatorial complexity is large enough for manual solving to be impossible, while remaining within the range where supervisory control techniques are tractable. The pace of control is more sporadic, and slower than the instruction-level computation performance within the coarse-grained tasks.
The objectives of Ctrl-A will be achieved and evaluated in both of our main application domains, thereby exhibiting their similarities from the point of view of reconfiguration control. A first application domain is High Performance Computing. In this area, we currently focus especially on the management of Dynamic Partial Reconfiguration in FPGA based hardware, at the level of middleware. Here the particular application we consider is, as in our ANR project HPeC starting end of 2015, video image flow processing for smart cameras implemented on DPR FPGASs themselves embedded in drones.
A second general application domain to confront our models is the Internet of Things (IoT), more specifically self-adaptive middleware platforms for Smart Environments, or Industry 4.0 related topics, like SCADA. We focus on providing coordination components and controllers of software components and services, or rule-based middleware platforms. The adaptation problems concern both the functional aspects of the applications in a smart building, and the middleware support deployment and reconfiguration issues. We are considering perspectives concerning self-protection and security.
Keywords: Compilers - Synchronous Language - Controller synthesis
Functional Description: Heptagon is an experimental language for the implementation of embedded real-time reactive systems. It is developed inside the Synchronics large-scale initiative, in collaboration with Inria Rhones-Alpes. It is essentially a subset of Lucid Synchrone, without type inference, type polymorphism and higher-order. It is thus a Lustre-like language extended with hierchical automata in a form very close to SCADE 6. The intention for making this new language and compiler is to develop new aggressive optimization techniques for sequential C code and compilation methods for generating parallel code for different platforms. This explains much of the simplifications we have made in order to ease the development of compilation techniques.
The current version of the compiler includes the following features: - Inclusion of discrete controller synthesis within the compilation: the language is equipped with a behavioral contract mechanisms, where assumptions can be described, as well as an "enforce" property part. The semantics of this latter is that the property should be enforced by controlling the behaviour of the node equipped with the contract. This property will be enforced by an automatically built controller, which will act on free controllable variables given by the programmer. This extension has been named BZR in previous works. - Expression and compilation of array values with modular memory optimization. The language allows the expression and operations on arrays (access, modification, iterators). With the use of location annotations, the programmer can avoid unnecessary array copies.
Participants: Adrien Guatto, Brice Gelineau, Cédric Pasteur, Eric Rutten, Gwenaël Delaval, Léonard Gérard and Marc Pouzet
Partners: UGA - ENS Paris - Inria - LIG
Contact: Gwenaël Delaval
Our work in reactive programming for autonomic computing systems is focused on the specification and compilation of declarative control objectives, under the form of contracts, enforced upon classical mode automata as defined in synchronous languages. The compilation involves a phase of Discrete Controller Synthesis, integrating the tool ReaX, in order to obtain an imperative executable code. The programming language Heptagon / BZR (see Section Software and Platforms) integrates our research results .
Recent work concerns exploring new possibilities offered by logico-numeric control. We consider Symbolic Limited Lookahead Control for Best-effort Dynamic Computing Resource Management. We put forward a new modeling technique for Dynamic Resource Management (DRM) based on discrete events control for symbolic logico-numerical systems, especially Discrete Controller Synthesis (DCS). The resulting models involve state and input variables defined on an infinite domain (Integers), thereby no exact DCS algorithm exists for safety control. We thus formally define the notion of limited lookahead, and associated best-effort control objectives targeting safety and optimization on a sliding window for a number of steps ahead. We give symbolic algorithms, illustrate our approach on an example model for DRM, and report on performance results based on an implementation in the tool ReaX. This work is in cooperation with the Sumo team at Inria Rennes (Hervé Marchand) and University of Liverpool (Nicolas Berthier), and is published in the WODES 2018 conference .
We also have ongoing activities on abstraction methods for compilation using discrete controller synthesis (needed for example, in order to program the controllers for systems where the useful data for control can be of arbitrary types (integer, real, ...) , or also for systems which are naturally distributed, and require a decentralized controller) and on compilation and diagnosis for discrete controller synthesis (which is made special by the declarative nature of the compilation, where it is not easy to precisely diagnose cases where no solution can be found).
On the applicative side, we also consider such modular and logico-numeric approaches for the control of different targets in self-adaptive and reconfigurable systems (see below in Section and , .
Our work in Domain-specific languages (DSLs) is founded on our work in component-based programming for autonomic computing systems as examplified by e.g., Fractal. We consider essentially the problem of specifying the control of components assembly reconfiguration, with an approach based on the integration within such a component-based framework of a reactive language as in Section .
In recent work, we proposed an extension of a classical Software Architecture Description Languages (ADL) with Ctrl-F, DSL for the specification of dynamic reconfiguration behavior in a .
Based on this experience, we are working on a proposal for a DSL called Ctrl-DPR, allowing designers to easily generate Autonomic Managers for DPR FPGA systems (see Section ). Users can describe their system and their management strategies, in terms of the entities composing the system : tasks, versions, applications, ressources, policies. The DSL relies on a behavioral modeling of these entities, targeted at the design of autonomic managers to control the reconfigurations in such a way as to enforce given policies and strategies. These model-based control techniques are embedded in a compiler, connected to the reactive language and discrete controller synthesis tool of Section , which enables to generate a C implementation of the controller enforcing the management strategies. We apply our DSL for the management of a video application on a UAV. This work is in cooperation with LabSticc in Lorient (Jean-Philippe Diguet), and is published in the ICAC 2018 conference .
Ongoing work involves a generalization from our experiences in software components, DPR FPGA, as well as Rule-based autonomic manager as in Section . As we observed a similarity in objects and structures (e.g., tasks, implmentation versions, resources, and upper-level application layer), we are considering a more general DSL, which could be specialized towards such different target domains, and where the compilation towards reactive models could be studied and improved, especially considering the features of Section . This direction will also lead us to study the definition of architectural patterns for multiple loop Autonomic Managers, particularly hierarchical, with lower layers autonomy alleviating management burden from the upper layers.
This work concerns a high-level language for safe rule-based programming in the LINC transactional rule-based platform developed at CEA . Rule based middlewares such as LINC enable high level programming of distributed adaptive systems behaviours. LINC also provides the systems with transactional guarantees and hence ensures their reliability at runtime. However, the set of rules may contain design errors (e.g. conflicts, violations of constraints) that can bring the system in unsafe safe or undesirables states, despite the guarantees provided by LINC. On the other hand, automata based languages such as Heptagon/BZR enable formal verification and especially synthesis of discrete controllers to deal with design errors. Our work studies these two languages and combines their execution mechanisms, from a technical perspective. We target applications to the domain of Internet of Things and more particularly smart building, office or home (see Section ).
This work is in cooperation with CEA LETI/DACLE (Maxime Louvel), it was the topic of the PhD of Adja Sylla at CEA, co-advised with M. Louvel, and aspects on applications of logico-numeric control are published in the CCTA 2018 conference .
We apply the results of the previous axes of the team's activity, as well as other control techniques, to a range of infrastructures of different natures, but sharing a transversal problem of reconfiguration control design. From this very diversity of validations and experiences, we draw a synthesis of the whole approach, towards a general view of Feedback Control as MAPE-K loop in Autonomic Computing .
A parallel program needs to manage the trade-off between the time spent in synchronisation and computation. This trade-off is significantly affected by its parallelism degree. A high parallelism degree may decrease computing time while increasing synchronisation cost. We performed work on dynamic control of thread parallelism and mapping. We address concurrency issues via Software Transactional Memory (STM). We implement feedback control loops to automate management of threads and diminish program execution time.
This work was performed in the framework on the PhD of Naweiluo Zhou, and published in the journal on Concurrency and Computation: Practice and Experience .
HPC systems are facing more and more variability in their behavior, related to e.g., performance and power consumption, and the fact that they are less predictable requires more runtime management. One such problem is found in the context of CiGri, a simple, lightweight, scalable and fault tolerant grid system which exploits the unused resources of a set of computing clusters. This work resulted in first results addressing the problem of automated resource management in an HPC infrastructure, using techniques from Control Theory to design a controller that maximizes cluster utilization while avoiding overload. We put in place a mechanism for feedback (Proportional Integral, PI) control system software, through a maximum number of jobs to be sent to the cluster, in response to system information about the current number of jobs processed. Additionally, we developed a Model-Predictive Controller to improve the performance of the system.
This work is done in cooperation with the Datamove team of Inria/LIG, and Gipsa-lab. It was the topic of the Master's thesis of Agustin Yabo . Preliminary results were published in the AIScience workshop (Autonomous Infrastructure for Science) of the HPDC conference .
Implementing self-adaptive embedded systems, such as UAV drones, involves an offline provisioning of the several implementations of the embedded functionalities with different characteristics in resource usage and performance in order for the system to dynamically adapt itself under uncertainties. We propose an autonomic control architecture for self-adaptive and self-reconfigurable FPGA-based embedded systems. The control architecture is structured in three layers: a mission manager, a reconfiguration manager and a scheduling manager. In this work we focus on the design of the reconfiguration manager. We propose a design approach using automata-based discrete control. It involves reactive programming that provides formal semantics, and discrete controller synthesis from declarative objectives.
This work is in the framework of the ANR project HPeC (see Section ), and is published in the International Workshop on High Performance and Dynamic Reconfigurable Systems and Networks (DRSN 2018), part of the HPCS 2018 conference ; for the evaluation of the apllication of logico-numeric control, in the CCTA 18 conference ; for the proposal of a Domain Specific Language, in the ICAC 2018 conference .
In the Mission Management workpackage of the ANR project HPeC, a concurrent control methodology is constructed for the optimal mission planning of a U.A.V. in stochastic environnement. The control approach is based on parallel ressource sharing Partially Observable Markov Decision Processes modeling of the mission. The parallel POMDP are reduced to discrete Markov Decision Models using Bayesian Networks evidence for state identification. The control synthesis is an iterative two step procedure : first MDP are solved for the optimisation of a finite horizon cost problem ; then the possible ressource conflicts between parallel actions are solved either by a priority policy or by a QoS degradation of actions, e.g., like using a lower resolution version of the image processing task if the ressource availability is critical.
This work was performed in the framework on the PhD of Chabha Hireche, and published in the journal on Sensors , .
A smart environment is equipped with numerous devices (i.e., sensors, actuators) that are possibly distributed over different locations (e.g., rooms of a smart building). These devices are automatically controlled to achieve different objectives related, for instance, to comfort, security and energy savings. Our work proposes a design framework based on the combination of the rule based middleware LINC and the automata based language Heptagon/BZR (H/BZR). It consists of: an abstraction layer for the heterogeneity of devices, a transactional execution mechanism to avoid inconsistencies and a controller that, based on a generic model of the environment, makes appropriate decisions and avoids conflicts. A case study with concrete devices, in the field of building automation, is presented to illustrate the framework.
This work is in the framework of the cooperation with CEA (see Section ), and is published in the CCTA 2018 conference .
The research topic is targeting an adaptative and decentralized management for the IoT. It will contribute design methods for processes in virtualized gateways in order to enhance IoT infrastructures. More precisely, it concerns Device Management in the case of large numbers of connected sensors and actuators, as can be found in Smart Home and Building, Smart Electricity grids, and industrial frameworks as in Industry 4.0.
This work is in the framework of the Inria/Orange labs joint laboratory (see Section ), and supported by the CIFRE PhD thesis grant of Neïl Ayeb, starting dec. 2017.
We focus mainly on vulnerability search, automatic attack vectors synthesis and intrusion detection. Model checking techniques are used for vulnerability search and automatic attack vectors construction. Intrusion detection is mainly based on process-oriented detection with a technical approach from run-time monitoring. The LTL formalism is used to express safety properties which are mined on an attack-free dataset. The resulting monitors are used for fast intrusion detections.
A demonstrator of attack/defense scenario in SCADA systems will be built on the existing G-ICS lab (hosted by ENSE3/Grenoble-INP).
This work is in the framework of the ANR project Sacade on cybersecurity of industrial systems (see Section ) .
The work is also supported by Grenoble Alpes Cybersecurity Institute (see Section ).
Ongoing work concerns the complementary topic of analysis and identification of reaction mechanisms for self-protection in cybersecurity, where, beyond classical defense mechanisms that detect intrusions and attacks or assess the kind of danger that is caused by them, we explore models and control techniques for the automated reaction to attacks, in order to use detection information to take the appropriate defense and repair actions.
Our cooperation with CEA (an EPIC, industrial and commercial public institution) concerns the LETI/LIST DACLE laboratory at Grenoble Minatec; it is bilateral, involving the CEA PhD grant of Adja Sylla (finished end of january 2018), to work with F. Pacull and M. Louvel on high-level programming on top of a rule-based middleware (See Sections and ).
We have a cooperation with Orange labs, around a CIFRE PhD grant, on the topic of autonomic device management (see Section ). This activity is part of the Inria/Orange joint laboratory.
We are starting a research action with Nokia / Bell labs, around a post-doctorate, co-advised with project-team Dyonisos at Inria Rennes, on the topic of the integration of FPGA-based accelerators in network nodes, and their reconfiguration management in coordination with higher level Software Defined Networks management. This activity is part of the Inria/ Nokia / Bell labs joint laboratory, and is in cooperation with the Dyonisos EPI at Inria Rennes Bretagne Atlantique (Yassine Hadjhadj), and the post-doctorate topic of Quang Pham Tran Anh.
The Grenoble Alpes Cybersecurity Institute aims at undertaking ground-breaking interdisciplinary research in order to address cybersecurity and privacy challenges. Our main technical focus is on low-cost secure elements, critical infrastructures, vulnerability analysis and validation of large systems, including practical resilience across the industry and the society.
In Ctrl-A, it is funding an internship position followed by a PhD position to be provided in September 2019 and supervised by Stephane Mocanu.
HPeC
is an ANR project on
Self-Adaptive, Energy Efficient High Performance Embedded Computing,
with a UAV case study
(http://
In Ctrl-A, it is funding a post-doc position, hired in Grenoble and co-advised with Lorient : Soguy Gueye. The work will be continued with a post-doc hired in Lorient : Erwan Moreac. A PhD based in Brest, Chabha Hireche, is co-advised by Stéphane Mocanu.
The ANR ASTRID Sacade project is funded by DGA. Stéphane Mocanu is in charge of several workpackages including a demonstrator. An expert engineer position is funded for the implementation of attack/defense scenarios in SCADA.
We have contacts with colleagues in France, in addition to the cooperation mentioned before, and with whom we are submitting collaboration projects, co-organizing events and workshops, etc. They feature : Avalon Inria team in Lyon (Ch. Perez, L. Lefevre, E. Caron), LIP6 (J. Malenfant), Scales Inria team in Sophia-Antipolis (L. Henrio), LIRRM in Montpellier (A. Gamatié, K. Godary, D. Simon), IRISA/Inria Rennes (J. Buisson, J.L. Pazat, ...), Telecom Paris-Tech (A. Diaconescu, E. Najm), LAAS (Thierry Monteil), LURPA ENS Cachan (J.M. Faure, J.J. Lesage).
We have ongoing discussions with several industrial actors in our application domains, some of them in the framework of cooperation contracts, other more informal: Eolas/Business decision (G. Dulac, I. Saffiedine), ST Microelectronics (V. Bertin), Schneider Electric (C. El-Kaed, P. Nappey, M. Pitel).
We participate in the jLESC, Joint Laboratory for Extreme Scale Computing, with partners Inria, the University of Illinois, Argonne National Laboratory, Barcelona Supercomputing Center, Jülich Supercomputing Centre and RIKEN AICS.
We participated to the 7th Workshop of the JLESC at Urbana-Champain in July 2017.
We started a cooperation with Argonne National Labs, on Improving the performance and energy efficiency of HPC applications using autonomic computing techniques.
https://
We are also exploring possibilities on the topic of integrating FPGAs in HPC grids, with a participation in a workshop at FPT 18.
We have ongoing relations with international colleagues in the emerging community on our topic of control for computing e.g., in Sweden at Lund (K.E. Arzen, M. Maggio), Mälardalen (A. Papadopoulos) and Linnaeus Universities (D. Weyns, N. Khakpour), in the Netherlands at CWI/leiden University (F. Arbab), in the U.K. at Liverpool U. (N. Berthier), in China at Heifei University (Xin An), in Italy at University Milano (C. Ghezzi, A. Leva), in the USA at Ann Arbor University (S. Lafortune) and UMass (P. Shenoy, E. Cecchet).
Eric Rutten is co-chairing, with Bogdan Robu (Gipsa-lab), the 40th Summer School of Automatic Control, Grenoble, September 2019, on the special topic of Control for Computing Systems.
Eric Rutten is
co-chair,
with A. Filieri (Imp. Coll. UK),
of the
International Workshop on Autonomic High Performance Computing,(AHPC 2018)
(http://
Eric Rutten is PC member for :
international conferences
ICAC 2018 (15th IEEE International Conference on Autonomic Computing), Sept 3-7, 2018, Trento, Italy
(http://
(Associate Editor)
2nd IEEE Conference on Control Technology and Applications, CCTA 18, Copenhagen, Denmark, August 21-24, 2018
(http://
14th Workshop on Discrete Event Systems, WODES'18, Sorrento Coast, Italy, May 30 - June 1, 2018.
(http://
AI-Science'18, workshop on autonomic cyberinfrastructure for science,
in conjunction with the ACM HPDC 2018, Tempe, AZ, United States, June 11, 2018
(http://
16th High Performance Computing & Simulation Conference (HPCS 2018). July 16 ? 20, 2018,Orléans, France
(http://
UCC Cloud Challenge event in conjunction with IEEE/ACM UCC/BDCAT 2018 in Zurich
(http://
ICAC 2019 (16th IEEE International Conference on Autonomic Computing),
Umeøa, Sweden, June 16 ? 20, 2 019
(http://
Eric Rutten is reviewer for SafeProcess 18 and CDC 18.
Stéphane Mocanu is reviewer for WODES'18.
Eric Rutten is reviewer for
Science of Computer Programming
IEEE TSC Transactions on Services Computing
IEEE Transactions on Industrial Informatics
Eric Rutten was invited to give a talk at :
FETCH 2018, Ecole d'Hiver francophone sur la technologie de conception des systèmes embarqués hétérogènes, 24-26 Janvier 2018, Saint Malo
http://
with J.Ph. Diguet,
:
WRC: 12th Workshop on Reconfigurable Computing
at HiPeac 2018,
https://
International Workshop on High Performance and Dynamic Reconfigurable Systems and Networks (DRSN 2018)
part of The International Conference on High Performance Computing & Simulation (HPCS 2018), July 16 ? 20, 2018, Orléans, France
http://
FETCH 2019, Ecole d'Hiver francophone sur la technologie de conception des systèmes embarqués hétérogènes, Louvain-la-Neuve, Belgique, 28-30 janvier 2019
http://
Eric Rutten is
co-chair
of the
Technical Committee on Discrete Event Systems (DESTC),
a part of the IEEE Control Systems Society (CSS) Technical Activities Board
(http://
Eric Rutten is member of the LIG laboratory council, and in charge of scientific relations between Inria Grenoble Rhône-Alpes and CEA Tech.
Licence : G. Delaval, Algorithmics and imperative programming, 18h class, 18h lab, L2, Université Grenoble Alpes
Licence : G. Delaval, Basis of software development : modularity, tests, 15h class, 15h lab, L2, Université Grenoble Alpes
Master : G. Delaval, Programming languages and compiler design, 33h, M1, Université Grenoble Alpes
Master : S. Mocanu, Computer Networks and Cybersecurity, 16h class, 34h lab, M1, Grenoble-INP/ENSE3
Master : S. Mocanu, Industriel Computer Networks, 8h class, 8h lab, niveau (M1, M2), M2, Grenoble-INP/ENSE3
Master : S. Mocanu, Reliability, 10h class, 8h lab, M2, Grenoble-INP/ENSE3
Master : S. Mocanu, Intrusion Detection and Defense in Depth labs, niveau M2, Grenoble-ENSE3/ENSIMAG
PhD : Oualid Koucham ; Détection d'intrusions dans les systèmes de contrôle industriels ; 12 nov. 2018 ; co-advised by S. Mocanu with J-M Thiriet (Gipsa-lab).
PhD in progress : Chabha Hireche ; Etude et implémentation d’une approche probabiliste de contrôle de mission de drone autonome ; oct. 2015 ; co-advised by S. Mocanu with Catherine Dezan (U. Bretagne Occidentale), and Jean-Philippe Diguet (U. Bretagne Sud).
PhD in progress : Neïl Ayeb ; Vers un management des objets de l'IoT décentralisé et adaptable ; dec. 2017 ; co-advised by Eric Rutten with S. Bolle, T. Coupaye (Orange labs).
The Ctrl-A team is featured in a special issue on the numeric world in the "Dauhiné Libéré des enfants" (nov.-dec. 2018).
The Ctrl-A team participated in the event "mon équipe en 180 secondes" at Inria Montbonnot.