The goal of the MOAIS team-project is to develop the scientific and technological foundations for parallel programming that enable to achieve provable performances on distributed parallel architectures, from multi-processor systems on chips to computational grids and global computing platforms. Beyond the optimization of the application itself, the effective use of a larger number of resources is expected to enhance the performance. This encompasses large scale scientific interactive simulations (such as immersive virtual reality) that involve various resources: input (sensors, cameras, ...), computing units (processors, memory), output (videoprojectors, images wall) that play a prominent role in the development of high performance parallel computing.
To reach this goal, MOAIS gathers experts in : algorithm design, scheduling, parallel programming (both low level and high level API), interactive applications. The research directions of the MOAIS team are focused on scheduling problems with a multi-criteria performance objective: precision, reactivity, resources consumption, reliability, ... The originality of the MOAIS approach is to use the application's adaptability to control its scheduling:
the application describes synchronization conditions;
the scheduler computes a schedule that verifies those conditions on the available resources;
each resource behaves independently and performs the decision of the scheduler.
To enable the scheduler to drive the execution, the application is modeled by a macro data flow graph, a popular bridging model for parallel programming (BSP, Nesl, Earth, Jade, Cilk, Athapascan, Smarts, Satin, ...) and scheduling. A node represents the state transition of a given component; edges represent synchronizations between components. However, the application is malleable and this macro data flow is dynamic and recursive: depending on the available resources and/or the required precision, it may be unrolled to increase precision (e.g. zooming on parts of simulation) or enrolled to increase reactivity (e.g. respecting latency constraints). The decision of unrolling/enrolling is taken by the scheduler; the execution of this decision is performed by the application.
The MOAIS project-team is structured around four axis:
Scheduling: To formalize and study the related scheduling problems, the critical points are: the modeling of an adaptive application; the formalization and the optimization of the multi-objective problems; the design of scalable scheduling algorithms. We are interested in classical combinatorial optimization methods (approximation algorithms, theoretical bounds and complexity analysis), and also in non-standard methods such as Game Theory.
Adaptive parallel and distributed algorithms: To design and analyze algorithms that may adapt their execution under the control of the scheduling, the critical point is that algorithms are either parallel or distributed; then, adaptation should be performed locally while ensuring the coherency of results.
Programming interfaces and tools for coordination and execution: To specify and implement interfaces that express coupling of components with various synchronization constraints, the critical point is to enable an efficient control of the coupling while ensuring coherency. We develop the Kaapi runtime software that manages the scheduling of multithreaded computations with billions of threads on a virtual architecture with an arbitrary number of resources; Kaapi supports node additions and resilience. Kaapi manages the fine grain scheduling of the computation part of the application. To enable parallel application execution and analysis. We develop runtime tools that support large scale and fault tolerant processes deployment (TakTuk), visualization of parallel executions on heterogeneous platforms (Triva).
Interactivity: To improve interactivity, the critical point is scalability. The number of resources (including input and output devices) should be adapted without modification of the application. We develop the FlowVR middleware that enables to configure an application on a cluster with a fixed set of input and output resources. FlowVR manages the coarse grain scheduling of the whole application and the latency to produce outputs from the inputs.
Often, computing platforms have a dynamic behavior. The dataflow model of computation directly enables to take into account addition of resources. To deal with resilience, we develop softwares that provide fault-tolerance to dataflow computations. We distinguish non-malicious faults from malicious intrusions. Our approach is based on a checkpoint of the dataflow with bounded and amortized overhead.
Best Paper - HeteroPar 2013
Best Long Paper - Second Prize at Web3D 2013
The goal of this theme is to determine adequate multi-criteria objectives which are efficient (precision, reactivity, speed) and to study scheduling algorithms to reach these objectives.
In the context of parallel and distributed processing, the term scheduling is used with many acceptations. In general, scheduling means assigning tasks of a program (or processes) to the various components of a system (processors, communication links).
Researchers within MOAIS have been working on this subject for many years. They are known for their multiple contributions for determining the target dates and processors the tasks of a parallel program should be executed; especially regarding execution models (taking into account inter-task communications or any other system features) and the design of efficient algorithms (for which there exists a performance guarantee relative to the optimal scheduling).
Parallel tasks model and extensions. We have contributed to the definition and promotion of modern task models: parallel moldable tasks and divisible load. For both models, we have developed new techniques to derive efficient scheduling algorithms (with a good performance guaranty). We proposed recently some extensions taking into account machine unavailabilities (reservations).
Multi-objective Optimization. A natural question while designing practical scheduling algorithms is "which criterion should be optimized ?". Most existing works have been developed for minimizing the makespan (time of the latest tasks to be executed). This objective corresponds to a system administrator view who wants to be able to complete all the waiting jobs as soon as possible. The user, from his-her point of view, would be more interested in minimizing the average of the completion times (called minsum) of the whole set of submitted jobs. There exist several other objectives which may be pertinent for specific use. We worked on the problem of designing scheduling algorithms that optimize simultaneously several objectives with a theoretical guarantee on each objective. The main issue is that most of the policies are good for one criterion but bad for another one.
We have proposed an algorithm that is guaranteed for both makespan and minsum. This algorithm has been implemented for managing the resources of a cluster of the regional grid CIMENT. More recently, we extended such analysis to other objectives (makespan and reliability). We concentrate now on finding good algorithms able to schedule a set of jobs with a large variety of objectives simultaneously. For hard problems, we propose approximation of Pareto curves (best compromizes).
Incertainties. Most of the new execution supports are characterized by a higher complexity in predicting the parameters (high versatility in desktop grids, machine crash, communication congestion, cache effects, etc.). We studied some time ago the impact of incertainties on the scheduling algorithms. There are several ways for dealing with this problem: First, it is possible to design robust algorithms that can optimized a problem over a set of scenarii, another solution is to design flexible algorithms. Finally, we promote semi on-line approaches that start from an optimized off-line solution computed on an initial data set and updated during the execution on the "perturbed" data (stability analysis).
Game Theory. Game Theory is a framework that can be used for obtaining good solution of both previous problems (multi-objective optimization and incertain data). On the first hand, it can be used as a complement of multi-objective analysis. On the other hand, it can take into account the incertainties. We are curently working at formalizing the concept of cooperation.
Scheduling for optimizing parallel time and memory space. It is well known that parallel time and memory space are two antagonists criteria. However, for many scientific computations, the use of parallel architectures is motivated by increasing both the computation power and the memory space. Also, scheduling for optimizing both parallel time and memory space targets an important multicriteria objective. Based on the analysis of the dataflow related to the execution, we have proposed a scheduling algorithm with provable performance.
Coarse-grain scheduling of fine grain multithreaded computations on heterogeneous platforms. Designing multi-objective scheduling algorithms is a transversal problem. Work-stealing scheduling is well studied for fine grain multithreaded computations with a small critical time: the speed-up is asymptotically optimal. However, since the number of tasks to manage is huge, the control of the scheduling is expensive. We proposed a generalized lock-free cactus stack execution mechanism, to extend previous results, mainly from Cilk, based on the work-first principle for strict multi-threaded computations on SMPs to general multithreaded computations with dataflow dependencies. The main result is that optimizing the sequential local executions of tasks enables to amortize the overhead of scheduling. This distributed work-stealing scheduling algorithm has been implemented in Kaapi.
This theme deals with the analysis and the design of algorithmic schemes that control (statically or dynamically) the grain of interactive applications.
The classical approach consists in setting in advance the number of processors for an application, the execution being limited to the use of these processors. This approach is restricted to a constant number of identical resources and for regular computations. To deal with irregularity (data and/or computations on the one hand; heterogeneous and/or dynamical resources on the other hand), an alternate approach consists in adapting the potential parallelism degree to the one suited to the resources. Two cases are distinguished:
in the classical bottom-up approach, the application provides fine grain tasks; then those tasks are clustered to obtain a minimal parallel degree.
the top-down approach (Cilk, Cilk+, TBB, Hood, Athapascan) is based on a work-stealing scheduling driven by idle resources. A local sequential depth-first execution of tasks is favored when recursive parallelism is available.
Ideally, a good parallel execution can be viewed as a flow of computations
flowing through resources with no control overhead. To minimize control overhead, the application has to be adapted: a
parallel algorithm on
However, this adaptation is restrictive. More generally, the algorithm should adapt itself at runtime to improve its performance by decreasing the overheads induced by parallelism, namely the arithmetic operations and communications. This motivates the development of new parallel algorithmic schemes that enable the scheduler to control the distribution between computation and communication (grain) in the application to find the good balance between parallelism and synchronizations. MOAIS has exhibited several techniques to manage adaptivity from an algorithmic point of view:
amortization of the number of global synchronizations required in an iteration (for the evaluation of a stopping criterion);
adaptive deployment of an application based on on-line discovery and performance measurements of communication links;
generic recursive cascading of two kind of algorithms: a sequential one, to provide efficient executions on the local resource, and a parallel one that enables an idle resource to extract parallelism to dynamically suit the degree of parallelism to the available resources.
The generic underlying approach consists in finding a good mix of various algorithms, what is often called a "poly-algorithm". Particular instances of this approach are Atlas library (performance benchmark are used to decide at compile time the best block size and instruction interleaving for sequential matrix product) and FFTW library (at run time, the best recursive splitting of the FFT butterfly scheme is precomputed by dynamic programming). Both cases rely on pre-benchmarking of the algorithms. Our approach is more general in the sense that it also enables to tune the granularity at any time during execution. The objective is to develop processor oblivious algorithms: similarly to cache oblivious algorithms, we define a parallel algorithm as processor-oblivious if no program variable that depends on architecture parameters, such as the number or processors or their respective speeds, needs to be tuned to minimize the algorithm runtime.
We have applied this technique to develop processor oblivious algorithms for several applications with provable performance: iterated and prefix sum (partial sums) computations, stream computations (cipher and hd-video transformation), 3D image reconstruction (based on the concurrent usage of multi-core and GPU), loop computations with early termination.
By optimizing the work-stealing to our adaptive algorithm scheme, the non-blocking (wait-free) implementation of Kaapi has been designed and leads to the C library X-kaapi.
Extensions concern the development of algorithms that are both cache and processor oblivious on heterogeneous processors. The processor algorithms proposed for prefix sums and segmentation of an array are cache oblivious too.
The goal of this theme is to develop approaches to tackle interactivity in the context of large scale distributed applications.
We distinguish two types of interactions. A user can interact with an application having only little insight about the internal details of the program running. This is typically the case for a virtual reality application where the user just manipulates 3D objects. We have a "user-in-the-loop". In opposite, we have an "expert -in-the-loop" if the user is an expert that knows the limits of the progam that is being executed and that he can interacts with it to steer the execution. This is the case for instance when the user can change some parameters during the execution to improve the convergence of a computation.
Some applications, like virtual reality applications, must comply with interactivity constraints. The user should be able to observe and interact with the application with an acceptable reaction delay. To reach this goal the user is often ready to accept a lower level of details. To execute such application on a distributed architecture requires to balance the workload and activation frequency of the different tasks. The goal is to optimize CPU and network resource use to get as close as possible to the reactivity/level of detail the user expect.
Virtual reality environments significantly improve the quality of the interaction by providing advanced interfaces. The display surface provided by multiple projectors in CAVE -like systems for instance, allows a high resolution rendering on a large surface. Stereoscopic visualization gives an information of depth. Sound and haptic systems (force feedback) can provide extra information in addition to visualized data. However driving such an environment requires an important computation power and raises difficult issues of synchronization to maintain the overall application coherent while guaranteeing a good latency, bandwidth (or refresh rate) and level of details. We define the coherency as the fact that the information provided to the different user senses at a given moment are related to the same simulated time.
Today's availability of high performance commodity components including networks, CPUs as well as graphics or sound cards make it possible to build large clusters or grid environments providing the necessary resources to enlarge the class of applications that can aspire to an interactive execution. However the approaches usually used for mid size parallel machines are not adapted. Typically, there exist two different approaches to handle data exchange between the processes (or threads). The synchronous (or FIFO) approach ensures all messages sent are received in the order they were sent. In this case, a process cannot compute a new state if all incoming buffers do not store at least one message each. As a consequence, the application refresh rate is driven by the slowest process. This can be improved if the user knows the relative speed of each module and specify a read frequency on each of the incoming buffers. This approach ensures a strong coherency but impact on latency. This is the approach commonly used to ensure the global coherency of the images displayed in multi-projector environments.The other approach, the asynchronous one, comes from sampling systems. The producer updates data in a shared buffer asynchronously read by the consumer. Some updates may be lost if the consumer is slower than the producer. The process refresh rates are therefore totally independent. Latency is improved as produced data are consumed as soon as possible, but no coherency is ensured. This approach is commonly used when coupling haptic and visualization systems. A fine tuning of the application usually leads to satisfactory results where the user does not experience major incoherences. However, in both cases, increasing the number of computing nodes quickly makes infeasible hand tuning to keep coherency and good performance.
We propose to develop techniques to manage a distributed interactive application regarding the following criteria :
latency (the application reactivity);
refresh rate (the application continuity);
coherency (between the different components);
level of detail (the precision of computations).
We developed a programming environment, called FlowVR, that enables the expression and realization of loosen but controlled coherency policies between data flows. The goal is to give users the possibility to express a large variety of coherency policies from a strong coherency based on a synchronous approach to an uncontrolled coherency based on an asynchronous approach. It enables the user to loosen coherency where it is acceptable, to improve asynchronism and thus performance. This approach maximizes the refresh rate and minimizes the latency given the coherency policy and a fixed level of details. It still requires the user to tune many parameters. In a second step, we are planning to explore auto-adaptive techniques that enable to decrease the number of parameters that must be user tuned. The goal is to take into account (possibly dynamically) user specified high level parameters like target latencies, bandwidths and levels of details, and to have the system automatically adapt to reach a trade-off given the user wishes and the resources available. Issues include multi-criterion optimizations, adaptive algorithmic schemes, distributed decision making, global stability and balance of the regulation effort.
Some applications can be interactively guided by an expert who may give advices or answer specific questions to hasten a problem resolution. A theoretical framework has been developed in the last decade to define precisely the complexity of a problem when interactions with an expert is allowed. We are studying these interactive proof systems and interactive complexity classes in order to define efficient interactive algorithms dedicated to scheduling problems. This, in particular, applies to load-balancing of interactive simulations when a user interaction can generate a sudden surge of imbalance which could be easily predicted by an operator.
This theme deals with the design and implementation of programming interfaces in order to achieve an efficient coupling of distributed components.
The implementation of interactive simulation application requires to assemble together various software components and to ensure a semantic on the displayed result. To take into account functional aspects of the computation (inputs, outputs) as well as non functional aspects (bandwidth, latency, persistence), elementary actions (method invocation, communication) have to be coordinated in order to meet some performance objective (precision, quality, fluidity, etc). In such a context the scheduling algorithm plays an important role to adapt the computational power of a cluster architecture to the dynamic behavior due to the interactivity. Whatever the scheduling algorithm is, it is fundamental to enable the control of the simulation. The purpose of this research theme is to specify the semantics of the operators that perform components assembling and to develop a prototype to experiment our proposals on real architectures and applications.
The specification of an API to compose interactive simulation application requires to characterize the components and the interaction between components.The respect of causality between elementary events ensures, at the application level, that a reader will see the last write with respect to an order. Such a consistency should be defined at the level of the application to control the events ordered by a chain of causality. For instance, one of the result of Athapascan was to prove that a data flow consistency is more efficient than other ones because it generates fewer messages. Beyond causality based interactions, new models of interaction should be studied to capture non predictable events (delay of communication, capture of image) while ensuring a semantic.
Our methodology is based on the characterization of interactions required between components in the context of an interactive simulation application. For instance, criteria could be coherency of visualization, degree of interactivity. Beyond such characterization we hope to provide an operational semantic of interactions (at least well suited and understood by usage) and a cost model. Moreover they should be preserved by composition to predict the cost of an execution for part of the application.
The main result relies on a computable representation of the future of an execution; representations such as macro data flow are well suited because they explicit which data are required by a task. Such a representation can be built at runtime by an interpretation technique: the execution of a function call is differed by computing beforehand at runtime a graph of tasks that represents the (future) calls to execute.
Managing the complexity related to fine grain components and reaching high efficiency on a cluster architecture require to consider a dynamic behavior. Also, the runtime kernel is based on a representation of the execution: data flow graph with attributes for each node and efficient operators will be the basis for our software. This kernel has to be specialized for the considered applications. The low layer of the kernel has features to transfer data and to perform remote signalization efficiently. Well known techniques and legacy code have to be reused. For instance, multithreading, asynchronous invocation, overlapping of latency by computing, parallel communication and parallel algorithms for collective operations are fundamental techniques to reach performance. Because the choice of the scheduling algorithm depends on the application and the architecture, the kernel will provide an causally connected representation of the system that is running. This allows to specialize the computation of a good schedule of the data flow graph by providing algorithms (scheduling algorithms for instance) that compute on this (causally connected) representation: any modification of the representation is turned into a modification on the system (the parallel program under execution). Moreover, the kernel provides a set of basic operators to manipulate the graph (e.g. computes a partition from a schedule, remapping tasks, ...) to allow to control a distributed execution.
We are pursuing and extending existing collaborations to develop virtual reality applications on PC clusters and grid environments:
Real time 3D modeling. An on-going collaboration with the MORPHEO project focuses on developing solutions to enable real time 3D modeling from multiple cameras using a PC cluster. An operational code base was transferred to the 4DViews Start-up in September 2007. 4DViews is now selling turn key solutions for real-time 3D modeling. Recent developments take two main directions:
Using a HMD (Head Mounted Display) and a Head Mounted Camera to provide the user a high level of interaction and immersion in the mixed reality environment. Having a mobile camera raises several concerns. The camera position and orientation need to be precisely known at anytime, requiring to develop on-line calibration approaches. The background subtraction cannot anymore be based on a static background learning for the mobile camera, required here too new algorithms.
Distributed collaboration across distant sites. In the context of the ANR DALIA we are developing a collaborative application where a user at Bordeaux (iParla project-team) using a real time 3D modeling platform can meet in a virtual world with a user in Grenoble also using a similar platform. We rely on the Grid'5000 dedicated 10 Gbits/s network to enable a low latency. The main issues are related to data transfers that need to be carefully managed to ensure a good latency while keeping a good quality, and the development of new interaction paradigms.
On these issues, Benjamin Petit started a Ph.D. in October 2007, co-advised by Edmond Boyer (PERCEPTION) and Bruno Raffin.
Real time physical simulation. We are collaborating with the EVASION project on the SOFA simulation framework. Everton Hermann, a Ph.D. co-advised by François Faure (EVASION) and Bruno Raffin, works on parallelizing SOFA using the KAAPI programming environment. The challenge is to provide SOFA with a parallelization that is efficient (real-time) while not being invasive for SOFA programmers (usually not parallel programmer). We developed a first version using the Kaapi environment for SMP machines that relies on a mix of work-stealing and dependency graph analysis and partitioning. A second version targets machines with multiples CPUs and multiple GPUs. We extended the initial framework to support a work stealing based load balancing between CPUs and GPUs. It required to extend Kaapi to support heterogeneous tasks (GPU and CPU ones) and to adapt the work stealing strategy to limit data transfers between CPUs and GPUs (the main bottleneck for GPU computing).
Distant collaborative work. We conduct experiments using FlowVR for running applications on Grid environments. Two kinds of experiments will be considered: collaborative work by coupling two or more distant VR environments ; large scale interactive simulation using computing resources from the grid. For these experiments, we are collaborating with the LIFO and the LABRI.
Parallel cache-oblivious algorithms for scientific visualization. In collaboration with the CEA DAM, we have developed a cache-oblivious algorithm with provable performance for irregulars meshes. Based on this work, we are studying parallel algorithms that take advantage of the shared cache usually encountered on multi-core architectures (L3 shared cache). The goal is to have the cores collaborating to efficiently share the L3 cache for a better performance than with a more traditional approach that leads to split the L3 cache between the cores. We are obtaining good performance gains with a parallel iso-surface extraction algorithm. This work is the main focus of Marc Tchiboukdjian Ph.D.
Code coupling aim is to assemble component to build distributed applications by reusing legacy code. The objective here is to build high performance applications for multi-cores, cluster or grid infrastructures.
Parallel programming model and runtime support. Programming parallel applications is a challenging problem. The MOAIS Team has a strong knowledge in parallel algorithms and develop a runtime support for scheduling parallel program written in a very high level interface. The parallelism from recursive divide and conquer applications and those from iterative simulation are studied. Scheduling heuristics are based on online work stealing for the former class of applications, and on hierarchical partitioning for the latter. The runtime support provides capabilities to hide latency by computation thanks to a non-blocking one-side communication protocol and by re-ordering computational tasks.
Grid application deployment. To test grid applications, we need to deploy and start programs on all used computers. This can become difficult if the real topology involves several clusters with firewall, different runtime environments, etc. The MOAIS Team designed and implemented a new tool called karun that allows a user to easily deploy a parallel application wrote with the Kaapi software. This Kaapi tool relies on the TakTuk software to quickly launch programs on all nodes. The user only needs to describe the hierarchical networks/clusters involved in the experiment with their firewall if any.
Visualization of grid applications execution. The analysis of applications execution on the grid is challenging both because of the large scale of the platform and because of the heterogeneous topology of the interconnections. To help users to understand their application behavior and to detect potential bottleneck or load unbalance, the MOAIS team designed and implemented a tool named Triva. This tool proposes a new three dimensional visualization model that combines topological information to space time data collected during the execution. It also proposes an aggregation mechanism that eases the detection of application load unbalance.
Large scale distributed platforms, such as the GRID and Peer-to-Peer computing systems, gather thousands of nodes for computing parallel applications. At this scale, component failures, disconnections (fail-stop faults) or results modifications (malicious faults) are part of operation, and applications have to deal directly with repeated failures during program runs. Indeed, since failure rate in such platform is proportional to the number of involved resources, the mean time between failure is dramatically decreased on very large size architectures. Moreover, even if a middleware is used to secure the communications and to manage the resources, the computational nodes operate in an unbounded environment and are subject to a wide range of attacks able to break confidentiality or to alter the resources or the computed results. Beyond fault-tolerancy, yet the possibility of massive attacks resulting in an error rate larger than tolerable by the application has to be considered. Such massive attacks are especially of concern due to Distributed Denial of Service, virus or Trojan attacks, and more generally orchestrated attacks against widespread vulnerabilities of a specific operating system that may result in the corruption of a large number of resources. The challenge is then to provide confidence to the parties about the use of such an unbound infrastructure. The MOAIS team addresses two issues:
fault tolerance (node failures and disconnections): based on a global distributed consistent state , for the sake of scalability;
security aspects: confidentiality, authentication and integrity of the computations.
Our approach to solve those problems is based on the efficient checkpointing of the dataflow that described the computation at coarse-grain. This distributed checkpoint, based on the local stack of each work-stealer process, provides a causally linked representation of the state. It is used for a scalable checkpoint/restart protocol and for probabilistic detection of massive attacks.
Moreover, we study the scalability of security protocols on large scale infrastructures. One goal is trusting the usage of remote-platforms (such as high-performance cluster or cloud infrastructure) by provding quantified guarantees on integrity, accountability and confidentiality. Within the global competitiveness cluster Minalogic, and in collaboration with Privatics team and industrial partners, we have developed a high-rate systematic ciphering architecture that provides red-black segregation on an Intenret network based on the coupling of a multicore architecture with security components (FPGA and smart card).
ACM: D.1.3
License: CeCILL
OS/Middelware: Unix (Linux, MacOSX, ...)
Programming language: C/C++, Fortran
Characterization of Software : A-3 / SO-4 / SM-3 / EM-3 / SDL-4
Own Contribution: DA-4 / CD-4 / MS-4 / TPM-4
Additional information:
Kaapi (http://
ACM: D.1.3
License: GPL and LGPL
OS/Middelware: Unix (Linux, MacOSX, ...)
Programming language: C/C++
Characterization of Software : A-3 / SO-4 / SM-3 / EM-3 / SDL-4
Own Contribution: DA-4 / CD-3 / MS-3 / TPM-4
Additional information:
FlowVR (http://
Characterization of Software : A-2 / SO-3 / SM-5 / EM-3 / SDL-4
Own Contribution: DA-4 / CD-4 / MS-4 / TPM-4
Additional information:
web site: http://
Objective of the software: TakTuk is a tool for deploying parallel remote executions of commands to a potentially large set of remote nodes. It spreads itself using an adaptive algorithm and sets up an interconnection network to transport commands and perform I/Os multiplexing/demultiplexing. The TakTuk mechanics dynamically adapt to environment (machine performance and current load, network contention) by using a reactive work-stealing algorithm that mixes local parallelization and work distribution.
Users community: TakTuk is a research open source project available in the Debian GNU/Linux distribution (package taktuk) used in lower levels of Grid5000 software architectures (nodes monitoring in OAR, environment diffusion in Kadeploy). The community is small : developers and administrators for large scale distributed platforms, but active.
Positioning: main competing tools are pdsh (but uses linear deployment) and gexec (not fault tolerant, requires installation), for more details : B. Claudel, G. Huard and O. Richard. TakTuk, Adaptive Deployment of Remote Executions. In Proceedings of the International Symposium on High Performance Distributed Computing (HPDC), 2009. TakTuk is the only tool to provide to deployed processes a communication layer (just like an MPIrun, but not tied to a specific environment) and synchronization capabilities.
Characterization of Software : A-2 / SO-4 / SM-5 / EM-3 / SDL-3
Own Contribution: DA-4 / CD-3 / MS-3 / TPM-3
Additional information:
web site: http://
Objective of the software: Triva is an open-source tool used to analyze traces (in the pajé format) registered during the execution of parallel applications. The tool serves also as a sandbox to the development of new visualization techniques.
Users community: Research open source project, applications developers, especially parallel applications.
Positioning: Main competing tools are Vampir (classical 2D Gantt charts) and Tau (less advanced agregation techniques), more details in : A Hierarchical Aggregation Model to achieve Visualization Scalability in the analysis of Parallel Applications. Lucas Mello Schnorr, Guillaume Huard, Philippe Olivier Alexandre Navaux. Parallel Computing. Volume 38, Issue 3, March 2012.
Characterization of Software : A-5 / SO-3 / SM-4 / EM-4 / SDL-5
Own Contribution: DA-3 / CD-2 / MS-1 / TPM-1
Additional information:
OAR (http://
ACM: D.1.3
Programming language: C/C++
Characterization of Software : A-5 / SO-4 / SM-4 / EM-4 / SDL-5
Own Contribution: DA-2 / CD-2 / MS-1 / TPM-1
Additional information:
SOFA (http://
Characterization of Software : A-3 / SO-4 / SM-2 / EM-3 / SDL-5
Own Contribution: DA-4 / CD-3 / MS-3 / TPM-4
Additional information:
web site: http://
Objective of the software: LinBox is an open-source C++ template library for exact, high-performance linear algebra computations. It is considered as the reference library for numerous computations (such as linear system solving, rank, characteristic polynomial, Smith normal forms,...) over finite fields and integers with dense, sparse, and structured matrices.
The LinBox group is an international collaboration (USA: NCSU, UDel; Canada: U Waterloo, U Calgary; France: LIP, LIRMM, LJK and LIG). Articles related to the library have been published in the main Conferences of the area: ISSAC, ICMS. MOAIS contributes to its development and more specifically to its parallelization in the context of ANR HPAC project. It is currently experiencing a major change of design, to better integrate parallelism.
Users community: mostly researchers doing computational mathematics (number theory, cryptology, group theory, persistent homology. They use the library by either linking against it directly (the library is packaged in Debian, Fedora, etc ) or withing the general purpose math software Sage (sagemath.org very broad diffusion) which includes LinBox as a kernel for exact linear algebra.
Moais collaborated with partners fromI2cat, Barcelona, Psnc, Poznan
and Grenoble-INP to setup a live distributed art performance for the
ICT 2013 conference at Vilnius. This distributed performance gathered
musicians located a Poznan, Barcelona and Vilnius, as well as a
dancer modeled in 3D on the Grimage platform at Inria Grenoble.
Though physically present in different cities these artists performed
together for a numerical dance and music performance numerically
assembled and transmitted in real-time at Vilnius. This joint effort
relies on the FlowVR framework from Moais and the UltraGrid software
from CESNET. This event received a significant attention from the
medias (In France: FR3 and Tele-grenoble, France inter, etc.). A video is available at
http://
Moais developed a framework for the parallelization of scientific visualization algorithms based on on-demand task extraction and work stealing techniques. This work is developed for the VTK software and supports the OpenMP, Intel TBB and Kaapi runtime environments. Mathias Ettinger visited the Kitware company, NY, for two months to prepare the integration of this work in the next release of VTK. This work is performed in collaboration with the EDF company.
We developped a novel adaptive sorting algorithm, called PaVO, relying on a Packed Mermory Array data structure. Maintaining gaps in the array of elements enable to reduce the span of modifications needed when reordering elements. This is particularly relevant in a parallel context to reduce the data dependencies. Performance results on a NUMA architecute show that PaVo outperfoms standard parallel sorting algorithms even for a large amount of disorder.
Internet Control Message Protocol (ICMP)i is essential for performance aspects in particular for Path Maximum Transmission Unit discovery but is also known to be a cause of attacks. In collaboration with Planet, we demonstrate, through a real exploit on a testbed, that an external attacker having eavesdropping and traffic injection capabilities in the black untrusted network, without any access to clear-text (thesis of Ludovic Jacquin). This impacts out current research on trusted outsourced computations.
We developped a novel scheduling algorithm in Kaapi to perform multi-GPUs execution of task' based program . Performance results on Cholesky factorization on up to 8-GPUs shows that Kaapi outperfoms similar runtime systems and even hand code parallel version.
Kaapi was ported natively on Intel Xeon Phi co-processor. Specific memory hierarchy was managed transparently to the applicaiton by the development of specific hierarchical work stealing scheduler. Experimentations on dense linear algebra kernels (Cholesky, LU and QR factorization) shows a very promising gain compared to the standard parallel implementation available in the Intel MKL . Extension of theses resultats are under publication process.
We port an adaptive loop scheduler from Kaapi into the OpenMP runtime library of GCC called libGOMP . The loop scheduler is consencious of the bloc data mapping to improve locality of computation.
Kaapi software developped by the MOAIS team was included in the standard EPX distribution. EPX has won the 2013 Grand Prix SFEN (http://
Contract with Bull (2013–2016). Multiobjective scheduling on supercomputer towards exascale. Associated to a CIFRE PhD grant (David Glesser, started in 4/2013). Partners: Inria - LIG Moais, Bull
Contract with EDF (2010-2013). High performance scientific visualization. Funds 1 postdoc and 1 PhD (Mathias Ettinger). Partners: Inria (MOAIS and EVASION), EDF R&D
CEA: Collaboration with CEA (2012): Europlexus Parallelization with KAAPI. Partners: Inria Rhônes-Alpes and CEA Saclay (CEA funds the PhD of Marwa Sridi started in 4/2013).
Action OCA : Combinatorial Optimization on Accelerator. Funding by Labex PERSYVAL Grenoble.
ANR grant REPDYN (2010-2013). High performance computing for structure and fluid computing. Partners: Inria Rhône-Alpes, CEA, ONERA, EDF, LaMSID lab from CNRS and LaMCoS lab from INSA Lyon.
ANR/JST grant PETAFLOW (2010-2013). France/Japan international program. Peta-scale data intensive computing with transnational high-speed networking: application to upper airway flow. Inria Rhône-Alpes, Gipsa-lab from UJF, NITC (Japan), Cyber Center of Osaka, DITS (Osaka) and the Visualization Lab of Kyoto.
ANR grant EXAVIZ (2011-2015). Large Scale Interactive Visual Analysis for Life Science. Partners: Inria Rhône-Alpes, Université d'Orléans, the LBT lab from IBPC, the LIMSI from Université d'Orsay, and the CEMHTI labs from CNRS.
ANR HPAC (2012-2015). High Performance Algebraic Computing. Coordinator: UJF (LJK/CASYS team). Partners: project-team MOAIS (Grenoble), project-team ARENAIRE (LIP, Lyon), project-team SALSA (LIP6, Paris), the ARITH group (LIRMM lab, Montpellier).
Equipex Kinovis (2012-2017). 2.6 Meuros. Large scale multi-camera platform (extension of the Grimage platform to 60 cameras, depth and X-ray cameras). Coordinator E Boyer, LJK Inria MORPHEO team. Partners: Inria Rhône-Alpes and the LJK, LIG, LADAF and GIPSA labs.
ANR-11-LABX-0025 PERSYVAL-Lab funds the following PhD in collaboration with other labs:
in collaboration with Verimag: Multi-objective optimization for resource management on multicore systems, (PhD Abhinav Srivastav, since 9/2012)
In collaboration with Gipsa-lab and Inria BiBop: Simulations of Fibrous Materials. (PhD Gilles Daviet, since 9/2013)
in collaboration with Inria Privatics and Verimag: Secure Outsourcing (PhD Amrit Kumar, since 11/2013)
SoC-Trace, Minalogic 2011-2014 contract. This project aims the development of tools for the monitoring and debug of mumticore systems on chip. Leader: ST-Microelectonic. Partners: Inria (Mescal, Moais); UJF (TIMA, LIG/Hadas); Magilem, ProBayes. Moais contributes with technics and tools for visual aggregation of application traces. The contract funds 1 phD thesis (Damien Dosimont) and 1 year engineer.
ADT K'STAR with cooperation between EPIs MOAIS and RUNTIME (Bordeaux). Coordinator: T. Gautier. https://
Since January 2013, the team is participating to the C2S@Exa
http://
T. Gautier is coordinator of the Pole 4: Programming Models.
Type: CAPACITIES
Defi: INFRA-2010-1.1.29
Instrument: Combination of COLLABORATIVE PROJECTS and COORDINATION and SUPPORT ACTIONS
Objectif: NC
Duration: February 2011 - January 2015
Coordinator: Frédéric Noël (Inpg)
Partner: Inria (France)
Inria contact: G. Dumont
Abstract: Visionair calls for the creation of a European infrastructure for high level visualisation facilities that are open to research communities across Europe and around the world. By integrating existing facilities, Visionair aims to create a world-class research infrastructure for conducting state-of-the-art research in visualisation, thus significantly enhancing the attractiveness and visibility of the European Research Area (ERA). With over 20 members across Europe participating, VISIONAIR offers facilities for Virtual Reality, Scientific Visualisation, Ultra High Definition, Augmented Reality and Virtual Services.
The MOAIS EPI is activiley participating to the international LICIA lab supporting collaborations with the UFRGG, Brazil. Bruno Raffin is member of the LICIA scientific comittee.
Moais is also leading a CAPES/COFECUB program (2013-2014) with UFRGS, Brazil.
Moais is also leading a CAPES/COFECUB program (2013-2014) with USP, Brazil.
Jacek Blazewicz (Professor, Polish Academy of Sciences, Poznań), invited prof INP (2 months)
Afredo Goldman (Professor, USP Sao Paulo) (1 month)
Daniel Cordeiro (Postdoc, USP Sao Paulo) (1 month)
Mario Cesar Lopez Loces (UFRGS) (1 month)
Adel Essafi (ISIG Kairouan, Tunis) (2 month)
Damien Dosimont, Oct-Dec 2013, UFRGS, Brazil
Clement Pernet, sabbatical, Sept-Dec 2013, LIP Lyon, Aric Team
Chair, Steering board:
Thierry Gautier, Chair of ComPAS'2013, Track Parallelism, located in Inria Grenoble, January 2013.
Bruno Raffin, Paper co-chair of JVRC 2013 (EGVE - EuroVR Joint Virtual Reality Conference).
Bruno Raffin, Member of the Steering Board of EGPGV (Eurographics Symposium on Parallel Rendering and Visualization)
Bruno Raffin, Member of the Steering Board of the journée visualisation scientifique.
Denis Trystram, Chair of the track Algorithms HiPC (20th Int'l Conf. on High Performance Computing), dec. 16-20, Hyderabad, India
Program committees:
ICCS 2013 (International Conference on Computational Science).
GPUCOMP 2013 (third Workshop on GPU Computing).
IEEE VR 2013.
ISVC 2013 (International Symposium on Visual Computing).
SEARIS 2013 (Workshop on Software Engineering and Architectures for Realtime Interactive Systems).
COMPASS, january 15-18 2013, Grenoble, France
IPDPS 2013 (24th IEEE International Parallel & Distributed Processing Symposium) may 20-24 2013, Boston USA
HCW'2013 (22nd IEEE Heterogeneous Computing Workshop) may, 2013, Boston USA
ISPDC (12th Internat Symposium on Parallel and Distributed Computing) june 27-30, 2013, Bucharest, Romania
OPTIM'13 (Workshop on Opt. Issues in Energy Efficient Distributed Systems) july 1-5, 2013, Helsinki, Finland
6th MISTA, august 27-29 2013, Ghent, Belgium
10th PPAM 2013, september 9-12, 2011, Warsaw, Poland
ParCo'2013, sept. 10-13, 2013, Munich, Germany
IC3 2012 (5th International Conference of Contemporary Computing) august 6-8, 2012, Noida, India
EuroMPI (20th internat conference) sept. 15-18, 2013, Madrid, Spain
ESA (21st European Symposium on Algorithms) sept. 2-6, 2013, Sophia Antipolia, France
25th SBAC-PAD, october 23-26, 2013, Pernambuco, Brazil
Master: J-L. Roch co-director (Grenoble-INP) with P Elbaz-Vincent (Université Joseph Fourier, Math. Dept) of the Master "SCCI Security, Cryptology and Coding of Information Systems" (M2) joined between UJF and INP Grenoble Universities. This Master, started in 2001, is taught in English from sept 2007 (international Master).
Master: C. Pernet and Denis Trystram are responsible of the first year (M1) of the international Master of Science in Informatics at Grenoble (MOSIG-M1).
Master: V Danjean: course "Parallel Programming" (M2), Grenoble University,.
Master: J-L. Roch, "Security models" 24h (M2), Grenoble University
Master: D. Trystram, P.-F. Dutot, J.-L. Roch, "Complexity, approximation theory and randomization" master course (M2) at Grenoble University
Master: François Broquedis. 192 hours per year. 192 hours per year. Engineering school Grenoble-INP/Ensimag, 1st year/L3 and Master (M1/2nd year and M2/3rd year).
Master: Vincent Danjean. 242 hours per year. Licence (third year) and Master (first and second year) at Joseph Fourier University. First to third year of engineering school at Polytech' Grenoble.
Master: Pierre-François Dutot. 226 hours per year. Licence (first and second year) at IUT2/UPMF (Institut Universitaire Technologique de l'Université Pierre Mendès-France) and 9 hours Master M2R-ISC Informatique-Systèmes-Communication at Joseph Fourier University.
Master: Guillaume Huard. 242 hours per year. Licence (first and third year) and Master (first year) at Joseph Fourier University.
Master: Grégory Mounié. 242 hours per year. Master (first year) and Computer Science for Non Computer Scientist Post-Master at Engineering school ENSIMAG and Dept TELECOM, Grenoble-INP.
Master: Clement Pernet. 210 hours per year. University J. Fourier. Master (first year and second year) and Licence (3rd year).
Master: Bruno Raffin. 22 hours per year. Master at Université d'Orléans and Polytech'Grenoble.
Master: Jean-Louis Roch. 242 hours per year. Engineering school Grenoble-INP/Ensimag and Master (M1/2nd year and M2/3rd year)
Master: Denis Trystram. 200 hours per year in average, mainly at first level of Engineering School.
Master: Frédéric Wagner. 220 hours per year. Engineering school ENSIMAG, Grenoble-INP (M1/2nd year and M2/3rd year) (190h) ; Master DESS/M2-P SCCI Security (30h).
PhD in progress : David Beniamine (since 2013). Parallelisation Patterns and Scheduling for Real-Time Physics Simulations. Co-advised Guillaume Huard and Bruno Raffin.
PhD in progress : Amrit Kumar (since 2013). Analysis of work-stealing and adpative algorithms. Labex-Persyval co-advised PhD by Pascal Lafourcade (Verimag lab), Cedric Lauradoux (Inria Privatics team) and Jean-Louis Roch.
PhD in progress : Gilles Daviet (since 2013). Parallel Macroscopic Simulations of Fibrous Materials. Co-advised by Florence Bertails-Descoubes, Pierre Saramito and Bruno Raffin.
PhD in progress : Julio Toss (since 2013). Parallel Algorithms and Data Structures for Physically Based Simulation of Deformable Objects. Join Ph.D with UFRGS, Brazil. Co-advised by Joao Comba and Bruno Raffin.
PhD in progress : Marwa Sridi (since 2013). Parallel Algorithm Composition for Transient Mechanic Simulations. Join Ph.D with CEA, France. Co-advised by Vincent Faucher, Thierry Gautier and Bruno Raffin.
PhD in progress : Ziad Sultan (since 2012). Hig-performance algebraic computations. Co-advised Ph.D by Jean-Guillaume Dumas (LJK Lab) and Clément Pernet.
PhD in progress : Mathias Ettinger (since 2011). Cache Efficient Parallel Adaptive Algorithms for Scientific Visualization. Co-advised by Bruno Raffin and François Broquedis
PhD in progress : Stefano Mor (since 2011). Analysis of work-stealing and adpative algorithms. Join Ph.D with UFRGS, Brazil. Co-advised by Jean-Louis Roch, Nicolas Maillard and Bruno Raffin
PhD in progress : Mathieu Dreher (since 2011). In-Situ Visualization for Molecular Dynamics. Advised by Bruno Raffin.
PhD in progress : Joao Ferreira Lima (since 2010). Work Stealing on GPUs. Join Ph.D with UFRGS, Brazil. Co-advised by Vincent Danjean, Thierry Gautier, Nicolas Maillard and Bruno Raffin
i