Yiannis Georgiou

Emmanuel Jeannot

Guillaume Mercier

Adèle Villiermet

Topology-aware resource management for HPC applications

Keywords: resource management, job allocation, topology-aware placement, scheduling, Slurm calcul scientique, HPC, gestionnaire de ressources, topologie, placement de processus

The Resource and Job Management System (RJMS) is a crucial system software part of the HPC stack. It is responsible for eciently delivering computing power to applications in supercomputing environments. Its main intelligence relies on resource selection techniques to nd the most adapted resources to schedule the users' jobs. Improper resource selection operations may lead to poor performance executions and global system utilization along with increase of system fragmentation and jobs starvation. These phenomenas play a role in the increase of the platforms' total cost of ownership and should be minimized. This paper introduces a new topology-aware resource selection algorithm to determine the best choice among the available nodes of the platform based upon their position within the network and taking into account the applications communication matrix. To validate our approach, we integrated this algorithm as a plugin for Slurm, a popular and widespread HPC resource and job management system (RJMS). We validated our plugin with dierent optimization schemes by comparing with the default Slurm algorithm using both emulation of a large-scale platform, and by carrying out experiments in a real cluster.

Introduction

Computer science is more than ever a cornerstone of scientic developement, as more and more scientic elds resort to simulations in order to help rene the theories or conduct expriments that cannot be carried out in reality because their scale or their cost are prohibitive. Currently, such computing power can be delivered only by parallel architectures. Larger and larger machines are being built around the world, and being able to display such a machine has become a challenge for states and nations, both scienticaly or politicaly.

However, harnessing the power of a large parallel computer is no easy task, because of several factors. First, it features most of the time a huge amount of computing nodes, and this scale has to be taken into account when developing applications. Then, the nodes architecture has become more and more complex, as the number of cores per node is in constant increase from one generation of CPU to the next. The memory hierarchy becomes also more complex, as various levels of cache are now available and the rise of MCDRAM or NVRAM will make things even more complicated in the future. Indeed, an ecient exploitation of all these types of memory is only possible if the programer takes it into account when developing his application.

One way of dealing with this complexity would be to take into account the application behavior (e.g its communication pattern, or its memory access pattern) and to deploy it on the computer accordingly. To this end, the most widespread technique is to determine the list of cores on which the application has to be run and then to bind the processes on these cores so as to minimize/maximze a predetermined criterion (a.k.a a metric). Such a technique has already been used and investigated to improve the performance of parallel applications [START_REF] Jeannot | Near-Optimal Placement of MPI processes on Hierarchical NUMA Architectures[END_REF]. However, since a parallel machine can be very large, it is often shared by many users running their applications at the same time. In such a case, an application execution will depend on a nodes allocation that has been determined by the Resources and Jobs Management System (RJMS). Most of the time, they work in a best-eort fashion, which can lead to suboptimal alloctions. That is such allocations might be able to fulll an application requirements in terms of resources (number of CPUs, amount of memory) but might also fail to provide an environment tailored for an optimzed execution. For instance, if the application processes communicate a lot between themselves, a set of nodes physically allocated apart from the rest might degrade performance serverly.

As a consequence, the idea would be to apply to resource management the same technique that has proved its eciency for application deployment and execution, that is, taking into account an application's behaviour in the process of reserving and allocating the needed resources (computing nodes). That means more criteria to be used and taken in consideration by the RJMS when a user submits its request to the system. Actually, taking in account an application behaviour when allocating nodes pushes even further the idea of using an application information to improve its execution.

In this paper, we shall detail the iprovements we made to an existing RJMS in order to enable it to select the most suitable set of nodes for a given parallel application. To this end, we did integrate our TreeMatch algorithm in the Slurm software to improve its ability to match its selection of resources to the actual use of the application. This paper is organized as follows: Section 2 gives an overview of the context and background of this work. Section 3 introduces all the software leveraged by this work before giving more more technical insights about the integration of TreeMatch into Slurm. Then Section 4 shows ans discusses the results obtained while related works are listed in Section 5. Finally, Section 6 concludes this paper. A large parallel computer goal is to some extent a tool that has to be exploited and used. A reason why these computers increase in size and scale stems from the fact that some applications also grow accordingly Therefore, an adequate platform has to match these needs. However, a substantial part of the time, this large platform not only works in a time-sharing mode, but also in a space-sharing mode. Indeed, in order to exploit the hardware in a satisfactory fashion, several users share it and this number of users can be potentially very large. An interactive access is therefore out of the question. To this end, the users have to submit theit requests in terms of resources to a system called the Resource and Job Manager System (sometimes called in short a Batch Scheduler). This system goals are threefold: 1 to centralize and analyze all the received requests, 2 to allocate in the most relevant fashion the resouces (CPU, memory or network switches for instance) able to full these demands and 3 to execute the application (a.k.a the job) submitted by a user on the set of selcted resources.

RR n°8859

The question that pertains to this selection and allocation of resources process is the one of the criteria that should be optimized by the RJMS since there are many and sometimes conicting one with another. For instance, one metric could be the system thoughput, that is, the amount of jobs executed during a dened time step, whilst one other could be the use (CPU load) of the system. All these metrics are relevant and which to use/optimze depends on a given point of view. That is, an administrator's point of view might diverge from a user's point of view. Indeed the users hardly possess a global view of the system (in most of cases) as opposed to the administrators, hence the discrepancy.

Finding an Optimization Criterion

In this work, we focused on a metric relevant for users: the execution time of the submitted application. We believe that it is the most appealing one for a user seeking to gather results and know the outcome of his/her application as soon as possible. The question that now arise is how to speed up an application execution? Let us suppose that the developer has already optimized his application as much as it is possible. What are the means left to even speed things further up? One answer lies in the ecosystem of the application, in the way the applicaton is deployed and executed. In a previous work, unrelated to resource management and job scheduling, we showed that by taking into account an application behaviour when deploying it on the various processing entities (CPUs, cores, threads, etc.), it is possible to improve its global execution time [START_REF] Mercier | Towards an Ecient Process Placement Policy for MPI Applications in Multicore Environments[END_REF][START_REF] Jeannot | Process Placement in Multicore Clusters: Algorithmic Issues and Practical Techniques[END_REF]. Actually, we try to improve the way an application accesses its data. This data locality can be improved in several ways, but we chose so far to use the communication pattern of the application, that is, an expression of the amount of bytes/messages exchanged by the application processes. Then, we try to match this pattern to the underlying architecture by following the principle that the more processes are communicating with the others, the closer cores they should be bound to. This can be done by several techniques but usually involves process binding and rank reordering [START_REF] Mercier | Improving MPI Applications Performance on Multicore Clusters with Rank Reordering[END_REF]. However, the execution is still dependent of the set of resources allocated to the application by the RJMS. Since no guarantee is given that this allocation will be compliant with the communication pattern of the application, some negative side eects can occur. For instance a subset of nodes might be physically far from another subset, thus impacting the communication between processes belonging to each subsets. As a consequence, we believe that an allocation that takes into account an application communication scheme might lead to performance improvements. To that end, we considered a well-known and widespread RJMS, called Slurm and we integrated Inria Table 1: Anity matrix for 8 processes (4 groups of 2 processes each)

our TreeMatch algorithm within Slurm as a plugin. So far, TreeMatch was used to compute a matching between the application processes and the physical cores available. Now, we use it to determine a nodes allocation before deploying the application.

A Motivating Example

The goal of this work is to apply TreeMatch before the execution of the application processes and compare dierent approaches. We assume that we know the communication pattern of the application at submission time. Such a communication pattern can be gathered through application monitoring (see Section 3.1.2) or by analyzing the structure of the parallel algorithm (for instance if we are dealing with a stencil code we know which processes are communicating together and the amount of exchanged data). In any case, we assume that this communication pattern remains unchanged from one run to the other. It is not the case for all parallel applications but a large amount of applications ts in these models (for instance, dense linear applications and kernels: LU factorization, Cholesky factorization, etc.).

Several possibilities are available. The obvious one is not to use TreeMatch at all and let the Slurm environment deal with the topology by itself. The second possibility is to apply TreeMatch just before the job execution and once Slurm has selected the resources. Another possibility is to use TreeMatch inside the selection mechanism of Slurm.

An example of the dierence between these approaches is depicted by Fig. ??. Let us suppose that We have 6 nodes composed of two computing entities each. We assume that node n3 is not available and hence computing entities 6 and 7 are already used by an other application and are then unavailable for job allocation. Lest us assume that a newly submitted job requests 4 nodes. For the sake of simplicity, we group processes in pairs (0-1, 2-3, etc.) and hence each pair of processes shall be assigned one node. The anity matrix is given in table 1.

If Slurm has to allocate resources for these 8 processes, it will look for the smallest subtree able to fulll the request. In this case, it requires to use the whole tree. Then, it will allocate processes from left to right in a round-robin fashion inside nodes. It will allocate nodes 0, 1, 2 and 4 for the job and then map processes onto the computing entities. We can see that such an allocation is rather costly communication-wise as groups of processes are spread onto the entities and no optimization is enforced in this regard. It is therefore possible to call TreeMatch to optimize the process mapping on these entities. By doing so, the resulting mapping is: group 0-1 on n0, group 6-7 on n1, group 2-3 on n2 and 4-5 on n4. This is the best possible solution once the resources have been allocated. However, group 2-3 communicates a lot with group 4-5. With such an allocation, all the communications will transit through the root of the topology, a costly solution in terms of hops. However, a better outcome is achievable if TreeMatch performs the resource allocation. Given such a topology and the above anity matrix, TreeMatch will allocate group 0-1 on n0, group 6-7 on n1, group 2-3 on n4 and 4-5 on n5 since there are constraints on node n3. In this case, all the communication between group 2-3 and group 4-5 will take only 2 hops instead of 4 and therefore the communication cost is even more reduced.

RR n°8859

3

A Topology-Aware Resource and Job Management System 3.1 Existing software

In this section, we introduce with more details the various software elements that we used to implement the work described in this paper. First, we shall describe Slurm, our target RJMS.

Then, we shall explain the method employed to gather information about the application communication scheme (a.k.a our anity matrix ). Then, we give more specic information about the TreeMatch algorithm.

SLURM

We implemented the new topology-aware placement algorithm upon the open-source resource and job management system Slurm [START_REF] Andyb | Slurm: Simple linux utility for resource management[END_REF]. Slurm performs workload management on six of the ten most powerful computers in the world of the Top500 list 1 including the system ranked number one, Tianhe-2 which features 3,120,000 computing cores.

Slurm is specically designed for the scalability requirements of state-of-the-art supercomputers. It is based upon a centralized server daemon, slurmctld known as the controler, which communicates with client daemons slurmd running on each computing node. Users can request the controller for resources to execute interactive or batch applications, referred to as jobs. The controller dispatches the jobs on the available resources, whether full nodes or partial nodes, according to a congurable set of rules. The Slurm controller also features a modular architecture composed of plugins responsible for dierent actions and tasks such as: job prioritization, resources selection, task placement or accounting. The resource selection process within SLURM takes place as part of the global job scheduling procedure. In particular, this procedure makes use of the plugin/select, which is responsible for allocating the computing resources to the jobs. Other plugins are used to facilitate and extend this procedure such as plugin/topology which takes into account the network topology of the 1 http://top500.org/lists/2015/11/ Inria cluster, the plugin/gres which can extend the allocation to dierent generic resources and the plugin/task which provides the isolation and possible binding of tasks on the resources.

There are various resource selection plugins within Slurm that can take into account the specicities of the underlying platforms' architecture such as linear and cons_res. The select/linear plugin allows the allocation of complete nodes for jobs, using simple and scalable best-t algorithms, however, the lower granularity of allocatable unit is the node which is quite limiting for new multicore and manycore architectures. The select/cons_res plugin is ideal for this type of architectures where nodes are viewed as collection of consumable resources ( such as cores and memory). In this plugin nodes can be used exclusively or in a shared mode where a job may allocate its own resources dierent than other job using the same node. The algorithms within cons_res plugin are also scalable featuring best-t placement of jobs but they are more complex than select/linear since a ner granularity of allocatable resources is taken into account. One of the rst versions of the select/cons_res plugin is described in [START_REF] Balle | Enhancing an open source resource manager with multi-core/multi-threaded support[END_REF].

Our studies and developments as described in the following sections are based upon the select/cons_res plugin therefore we try to analyze a bit more some important internals of this plugin. The internal representation of resources and availabilities within Slurm is made using bitmap data structures. In the case of linear plugin only node bitmap is needed whereas in the case of cons_res plugin besides the node bitmap, a core bitmap is used to represent internal node resources availabilities. Within the cons_res plugin the usage of node and core bitmaps is leveraged eciently (kept separated in dierent contexts) in order to keep a high scalability for the selection algorithms. Another functionality of the cons_res plugin is the distribution of tasks within the allocated resources, which is an important feature for the optimal performance of parallel applications.

Slurm provides conguration options to make the resources selection network topology-aware through the activation of the topology plugin topology/tree plugin) A particular le describing the network topology is needed and the job placement algorithms favor the choice of group of nodes that are connected under the same network switch. The goal of the Slurm topology-aware placement algorithms is to minimize the number of switches used for the job and provide a bestt selection of resources based on the network design. This feature becomes indispensable in the case of pruned buttery networks where no direct communication exist between all the nodes.

The scalability and eciency of topology-aware resource selection of Slurm has been evaluated in [START_REF] Georgiou | Evaluating scalability and eciency of the resource and job management system on large HPC clusters[END_REF] Finally since cons_res plugin deals with multi-core architectures the isolation and binding of tasks upon the used resources is an important feature to guarantee a minimal interference between jobs sharing nodes. This feature takes place through the usage of task/affinity or task/cgroup plugins which use linux kernel mechanisms such as cgroups and cpusets or APIs such as hwloc in order to provide the described isolation and binding.

Application Monitoring

For this work we need to model an application communication scheme. The way communications occur describes the anity between processes. To optimize the communications of a given application we therefore need to place application processes according to their anity and the underlying physical topology. The topology information is supplied either by the RJMS or by tools such as netloc2 and hwloc [START_REF] Broquedis | Hwloc: a Generic Framework for Managing Hardware Anities in HPC Applications[END_REF].

As for the anity matrix, we gather the communication pattern thanks to a dynamic monitoring component we integrated in Open MPI as an MCA (Modular Component Architecture) framework called pml (point-to-point management layer). This component, when activated at launch time (through the mpiexec option --mca pml_monitoring_enable), monitors all the communications at the lowest level in the Open MPI stack (i.e. once collective communications have been decomposed into point-to-point operations). Therefore, as opposed to the standard MPI proling interface (PMPI) approach where the MPI calls are intercepted, we monitor in our case the actual point-to-point communications that are issued by Open MPI, which is much more precise: for instance, we can see the tree used for aggregating values in a MPI_Gather call.

Internally, this component uses the low-level process ids and creates an associative array to convert sender and receiver ids into ranks in MPI_COMM_WORLD. Each time a message is sent, the sending process increments two arrays entries: the number of messages and the amount of bytes sent to the receiver. At the end of the execution, each process dumps its local view into a le and a script aggregates all the local views at a given process to get the full communication matrix. This monitoring component will be released in Open MPI 2.0 and a prototype is already available on the Open MPI github platform.

TreeMatch

TreeMatch [START_REF] Jeannot | Process Placement in Multicore Clusters: Algorithmic Issues and Practical Techniques[END_REF] [10], is a library for performing process placement based on the topology of the machine and the communication pattern of the application for multicore, shared memory machines as well as distributed memory machines. It computes a permutation of the processes to the processors/cores in order to minimize the communication cost of the application.

It is also integrated in the Charm++ programming environment as an ecient load-balancer [START_REF] Jeannot | Communication and topology-aware load balancing in charm++ with treematch[END_REF] and in Open MPI [START_REF] Mercier | Improving MPI Applications Performance on Multicore Clusters with Rank Reordering[END_REF] to enable rank reordering in virtual topology management routines (e.g.

MPI_Dist_graph_create).

To be more specic, it takes as input a tree topology (where the leaves stand for computing resources and internal nodes correspond to switches or cache levels) and a matrix describing the graph anity between processes. A hierarchy is extracted from this graph such that it matches the hierarchy of the topology tree. The outcome is a mapping of the processes onto the computing resources. The objective function optimized by TreeMatch is the Hop-Byte [START_REF] Yu | Topology mapping for blue gene/l supercomputer[END_REF], that is, the number of hops weighted by the communication cost:

Hop-Byte(σ) = 1≤i<j≤n ω(i, j) × d(σ(i), σ(j))
where n is the number of processes to map, σ is the process permutation output produced by TreeMatch (process i is mapped on computing resource σ(i)), A = (ω i,j ) 1 ≤ i ≤ n, 1 ≤ j ≤ n is the anity matrix between these entities and hence ω(i, j) is the amount of data exchanged between process i and process j and d(p 1 , p 2 ) is the distance, in number of hops, between computing resources p 1 and p 2 .

An important feature of TreeMatch lies in its ability to take constraints into account.

When not all leaves are available for mapping (because some of them are already used by other applications such as in this paper), it is possible to restrict the leaves onto which processes can be mapped such that only a subset of nodes is used for the mapping. Another important feature of TreeMatch is that it only uses the structure of the tree and does not require a precise valuation of the speed of the links in the topology. Therefore TreeMatch does not require a performance assessment of the system on which the application is going to be executed. We believe this to be a strong advantage, as gathering such information is error-prone, might be incomplete and subject to inaccuracy.

In Fig 2, we describe an example where we map 4 processes on an architecture featuring 8 computing resources and structured as a 3-levels tree. We display 2 cases: one without constraints and the other where only cores with even numbers are available for mapping. The rst line is without constraints: in this case the hop-byte metric is 360. The second line is when only cores with even numbers are allowed to execute processes (hop-bye is 660 in this case)

TreeMatch Integration within SLURM

We have implemented a new selection option for the Slurm cons_res plugin In this case the regular best-t algorithm used for nodes selection is replaced by TreeMatch.

To this end we need to provide three pieces of information: a job anity matrix, the cluster topology and the constraints due to other jobs allocations.

The communication matrix is provided at job submission time through a distribution option available in the srun command: srun -m TREEMATCH=/communication/matrix/path cmd #SBATCH -m TREEMATCH=/communication/matrix/path . Its location (path) is then stored by the Slurm controller in the data structure describing a job and can be used by TreeMatch for allocation.

As for the global cluster topology, it is provided to the controller by a new parameter in the conguration le: TreematchTopologyFile=/topology/file/path. With several queues we need a topology description for each of them.

Whenever a job allocation is computed, this topology is completed by constraints informations. These constraints are provided by the nodes and cores bitmaps used by the Slurm controller to describe the cluster utilization. We need to translate this topology description into the TreeMatch topology. TreeMatch considers computing units as selection granularity and assign them an id considering the global topology. It must be the same for the Slurm selection plugin using TreeMatch.

Hence we use the cons_res plugin with the conguration SelectTypeParameters=CR_CPU. In this case Slurm uses a cores bitmap describing precisely the location of unused cpus inside nodes relatively to the nodes bitmap. Therefore, we need to translate Slurm local cpu ids into global TreeMatch cpu ids. Then, we use the constraints feature of TreeMatch (described in Section 3.1) to only use cpus not already allocated to a running job. The cpus chosen by TreeMatch must then be translated again in new bitmaps for Slurm to use. However, in the case of a large topology, our algorithm overhead increases: the larger the topology, the longer the TreeMatch algorithm takes. To reduce this time, we also implemented an alternative method which rst nds a subtree in the global topology. Then, TreeMatch uses this subtree to rapidly choose the job allocation. To nd this subtree we search through the RR n°8859 topology tree from the leaves up to the root and from left to right. We stop as soon as we nd a node with enough unused cpus. For instance, if we consider Fig. 1 and we assume that node n0 is occupied instead of n3, then the rst tree with 2 cpus is n1 and if we need 6 cpus, we shall select subtree t1.

For the experiments described in Section 4 we need to modify the jobs run times dynamically according to their allocation. To do this we compute for each job both the Slurm allocation and the TreeMatch one. Then we compute R, the ratio between their hop-byte cost (c.f. Section 3.1). q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q 10 20 30 10 20 30

Measured timings (s) Modeled timings (s)

Comparison between model and measured execution time

T = T calc + RT comm = RαT + (1 -α)T = (1 + Rα -α)T
We validated this model with the minighost application [START_REF] Richard F Barrett | Minighost: a miniapp for exploring boundary exchange strategies using stencil computations in scientic parallel computing[END_REF] that computes a stencil in various dimensions. We executed 84 runs with various settings (number of processors, dierent parameters) using a round-robin placement or a mapping computed with TreeMatch.

The minighost output also provides the percentage of communication in a run. In our case, this ranges from 5% to 45%. Fig. 3 shows the validation of the above model. On the x-axis is the TreeMatch runtime and on the y-axis is the predicted time based on the ratio R of the hopbyte of the TreeMatch mapping and the Slurm mapping, α the percentage of communication and T the measured execution runtime. We see a very strong correlation between both timings even though the modeled timings tend to be slightly larger than the real ones.

4

Experimental Validation

Emulation Experimental Setup

Our experiments have been carried out on the Edel cluster from the Grid'5000 Grenoble site.

Edel is composed of 72 nodes with 2 Intel Xeon E5520 CPUs (2.27 GHz, 4 cores/cpu) and 24GB of memory.

We did emulate Curie (a TGCC cluster with 5040 nodes and 80640 cores3 ) using a Slurm internal emulation technique called multiple-slurmd initially described and used in [START_REF] Georgiou | Evaluating scalability and eciency of the resource and job management system on large HPC clusters[END_REF]. Slurm uses deamons: one slurmctld as the controller and one slurmd on each node. To emulate a larger cluster, we use 16 Edel nodes and launch 315 slurmd daemons on each node. We can consequently submit jobs as if we were working on the Curie cluster, emulating all the job scheduling overheads. We use simple jobs (just performing a call to sleep) in order to provide the necessary time and space illusion to the controller that a real job is actually executing. We based our experiments on a Curie workload trace taken from the Parallel Workload Archive 4 . We have two sets of jobs. the rst is to ll the cluster, and the jobs belonging to this set are always scheduled using Slurm in order to have the same starting point for all the experiments. The second set, called the workload, is the one we actually use to compare our dierent strategies.

Com SLURM TM-A TM-Isub

All the measurements are done through the Slurm loggin system which gives us workload traces similar to the ones we obtained from Curie.

Finally, to use TreeMatch we need to supply a matrix communication for each job. For these experiments we use matrices randomly generated with various sparsity rates.

Emulation Results

We compare 4 cases : the classical topology-aware Slurm selection (SLURM), the same but using TreeMatch for process placement after the allocation process and just before the execution starts (TM-A), TreeMatch used both for the allocation process and for the process placement (TM-I) and nally the same but using the subtree technique to reduce the overhead (TM-Isub).

To evaluate our results, we use several metrics (two are for the whole workload and two are for each individual job): makespan: this is the time taken between the submission if the rst job and the completion of the last job of the workload. utilization: this is the ratio between the cpus used and the total number of cpus in the cluster during the execution of the workload. job owtime: this is the time between the submission and the completion of a given job. job runtime: this is the the time between the start and the completion of a given job.

In our case, the workload comprises 60 jobs. To keep the duration reasonnable we decreased the jobs runtimes by a 0.5 factor. Figure 4 describes the results obtained for this workload and two values of α (1/3 and 1/2). Figure 4(a) shows that using TreeMatch to reorder the process ranks reduces the makespan but using it inside Slurm to allocate nodes decreases it even more. This is what is shown in Fig. 1: incorporating TreeMatch in Slurm gives more room for optimization as the mapping is not constraints by the allocation. Moreover, the subtree optimization leads to comparable results that without the optimization this is due to the fact that in this case the makespan is determined by a small set of jobs and hence the impact of this optimization is not visible for this metric. We also see that the larger the communication ratio the greater the gain, this is expected as TreeMatch optimization communication only. This is tested through simulation in Section 4. In Fig. 5 and Fig. 6, we use paired comparisons between dierent strategies for respectively jobs owtime and jobs runtime. Here, we consider job-wise metrics, therefore we want to understand if, when we average all the jobs, a strategy turns out the be better than one other. Each strategy is displayed on the diagonal. On the upper right, we have the average dierence between the strategy on the line and the one on the row and the geometric mean of the ratios. For instance, in Fig. 5(a), we see that on average the job owtime is 183.35s faster with TM-I than with SLURM and the average ratio is 1.06. On the lower left part, we plot the 90% condence interval of the corresponding mean. The interpretation is the following: if the interval is positive, then the strategy on the row is better than the strategy on the line with a 90% condence. In this case, the corresponding mean is highlighted in green. If the interval is negative the strategy on the line is better than the one on row and the corresponding mean is highlighted in red. Otherwise, we cannot statistically conclude with a 90% condence on which strategy is the best and we do not highlight the corresponding mean. For example, on Figure 5(a) we can see that using TreeMatch in is better than not using it. Moreover, here we see that using the subtree optimization improves the metric. For all the cases we see that TM-Isub is better than TM-I that is better than TM-A. Therefore, restricting the usage of TreeMatch improves the performance as the gain in computing a solution overcome the loss in terms of quality if this solution.

Moreover, both owtime and runtime using TreeMatch in Slurm are shorter than using TreeMatch after Slurm, with a ratio between 1.44 and 1.54. We can also see that the more an application communicates, the smaller are the average gaps. For example, between TM-I and TM-Isub (with a 33% of communication ratio), the average dierence is 22.5 s, but for a 50% ratio it is 10.2s. In these experiments, the cluster is already full when submitting the rst jobs. Figure 6 shows the comparison of jobs runtimes. We observe similar behavior except that the condence interval between SLURM and TM-A does not allow to conclude with 90% condence that TM-A is better than SLURM.

Through these experiments we observe that using TreeMatch in the allocation process induces no negative eects and improves the global use of a cluster. Moreover, from a user point of view, using TreeMatch can also be protable by decreasing the runtime of his/her jobs.

Simulation Results

As the experiments done in the above section are carried out through emulation, they are very long to compute (as long as the real execution times). In order to cover a larger set of test cases and a longer time-scale we have designed a simulator that simulates both the job selection part and the job execution part. For the job selection step, we have implemented the same algorithm than we used in the above section and the time to compute the allocation is based on the duration of TreeMatch when it used or is set to 2 seconds when Slurm is used. For the execution time part, we use the formula shown in Section 4.1 if we use TreeMatch. Otherwise, the duration given by the curie trace is used.

Our simulator is accurate enough to provide makespan duration with an average absolute error of less than 3% for Table 4(a).

Figure 7(a) shows the average ow of the jobs in the case where the machine is already full of jobs (that have all been scheduled using the regular Slurm strategy). We have grouped the measures by duration of the simulation (i.e. for group 50, we consider only the jobs submitted during the rst 50 hours): we go from 1 hour (365 jobs) to 100 hours (13687 jobs). On the x-axis we display the dierent percentage of communication (from 10% to 50%) and we have 7 strategies: the plain Slurm, TreeMatch applied at the beginning of the job to map processes to resources after Slurm has allocated the nodes (TM-A), and TreeMatch used in Slurm to compute the allocation and the mapping using the minimal subtree (TM-Isub), or 3 levels above the minimal subtree (TM-Isub+3). We see that that the impact of TreeMatch on the ow

RR n°8859

increases with the duration of the simulation because at the beginning of the simulation, as the machine is full the owtime depends mainly on the time a job has to wait before starting while as time goes the impact on the improvement of the mapping due to TreeMatch accumulates. Here, we do not see much dierence between the dierent strategies involving TreeMatch because there is less room for optimization when the machine is fully utilized. However, the results are consistent, in terms of quality with the emulation results presented in the previous section. Figure 7(b) shows the average ow of the jobs in the case where the machine is totaly empty.

In this case, we see that the gain with TreeMatch increases and appears earlier which corroborates the hypothesis made in the previous paragraph. Moreover, as we have more opportunities for optimization we see that using TreeMatch in Slurm is more benecial than using it just before the job execution. We also see a large gap for hour 5 because in the workload a large job (32768 cores) is submitted at 8461s, that takes a long time to schedule and that uses a substantial part of the machine, thus impacting all the subsequent jobs.

5

Related works and Discussion

The idea of using the most adequate hardware resource to a specic application is not new and has been explored in previous work. It has been particularly popular in the context of grids environments ( [START_REF] Liu | Design and evaluation of a resource selection framework for grid applications[END_REF], [START_REF] Sonmez | Communication-aware job placement policies for the koala grid scheduler[END_REF], [START_REF] Cipriano | Utility Computing: 15th IFIP/IEEE International Workshop on Distributed Systems: Operations and Management, DSOM 2004[END_REF]) where it is important to select the best set of resource (clusters in this case) to use. Such works try to reduce the impact of WAN communication in grids but do not address the deeper details of the physical topology, such as NUMA eects or cache hierarchy for instance. More recently, some works have targeted a specic type of applications, that is, MapReducebased applications. For instance, the TARA [START_REF] Lee | Topology-aware resource allocation for data-intensive workloads[END_REF] uses a description of the application to allocate the resources. However, this work is tailored for a very specic class of applications and does not address hardware details.

The mapping of a parallel applications' tasks to the physical processors based on the network topology can lead to important performance improvements [START_REF] Bhatele | Topology aware task mapping techniques: an api and case study[END_REF]. Network topology characteristics can be taken into account by the scheduler [START_REF] Navaridas | Reducing complexity in tree-like computer interconnection networks[END_REF] so as to favor the choice of group of nodes that are placed on the same network level, connected under the same network switch or even placed close to each other so as to avoid long distance communications. This kind of feature is taken into account by most of open-source and proprietary RJMS. However even if most of them use the characteristics of the underlying physical topology, in the end they fail to take into consideration the application behaviour when allocating resources and this is something that this work tries to address. HTCondor (formerly Condor) leverages a so-called matchmaking approach [START_REF] Raman | Matchmaking: Distributed resource management for high throughput computing[END_REF] that allows it to match the applications needs to the available hardware resources. However, the application behaviour is not part of this matchmaking and HTCondor targets both clusters and networks of workstations. Slurm [START_REF] Andyb | Slurm: Simple linux utility for resource management[END_REF], as previously described, provides an option to minimize the number of network switches used in the allocation, so as to reduce the communication costs during the application execution (switches that are the deeper in the tree topology are supposed to be the less costly than upper ones). The same idea of topology-aware placement is exploited by PBS Pro [START_REF] Pbsworks | [END_REF], Grid Engine [START_REF]Grid engine[END_REF], and LSF [START_REF] Smith | Topology aware scheduling in the lsf distributed resource manager[END_REF]. Os Fujitsu [START_REF]Interconnect topology-aware resource assignment[END_REF] provides the same but only for its proprietary Tofu network. As far as our knowledge, Slurm [START_REF] Andyb | Slurm: Simple linux utility for resource management[END_REF] remains the only one providing a best-t topology-aware selection whereas the others propose rst-t algorithms. Some other RJMS oer task placement options that can enforce a clever placement of the application processes. That is the case of Torque [START_REF]Torque resource manager[END_REF] which proposes a NUMA-aware job task placement. OAR [START_REF] Capit | A batch scheduler with high level components[END_REF] uses a exible hierarchical representation of resources which oers the possi-Inria bility to place the application processes upon the memory/cores hierarchy within the computing node. However, in these existing works, only the network topology is taken in account and the nodes internal architecture is left unaddressed when performance gains are expected from exploiting the memory hierarchy.

Several binding policies are available, and they are compatible with the policies implemented in Open MPI. In all these solutions, the user has to retrieve the architectural details before submitting his job. Also, the placement options oered leave the user with the burden to determine his/her policy beforehand, and the application communication scheme is not taken into account.

In our case, we improve this functioning on three levels : rst, we dtake into account not only the network but also the node internal structure. The information used is based on the structure of the nodes and the memory hierarchy. In other words, we do not use latency and bandwidth gures to compute ou allocation. Then, this information is retrived directly by our plugin does not have to be supplied by the user. All the technical details are hidden. Last, but not least, we also take into account not only the architecture but also the application behaviour both for the allocation and the execution of a job.

Conclusion and Future Work

Job scheduling plays a crucial role in cluster administration, enabling both better response time and resource usage. In this paper, we have tackled the problem of allocating and mapping jobs according to a cluster topology and application process anity. We have designed a new allocation policy that allocates and maps at the same time application processes on the resources, based on the communication matrix of the considered application. Such strategy has been implemented in the Slurm cons_res plugin. We have tested this strategy on emulation and simulation and compared it with the standard Slurm topology-aware policy and the method consisting in mapping processes after the allocation is determined. Results show that our solution provides better makespan, ow time, utilization and job runtime compared to these approaches and especially to the standard Slurm policy. We have also shown that the level at which we consider the topology impacts the performance. It is better to have a more local view of the topology than only a global view since in this latter case, allocation quality is slightly better but longer to compute. For future work, we would like to investigate the following research axes. First, We would like to look at fragmentation metrics. Indeed, the way jobs are allocated impacts the global resource usage and this aspect should be quantied. Also, we would like to nd means to gather in a systematic fashion applications communication patterns in order to create an applications classication based on these patterns and then implement this solution in production. We also like to validate this approach in other job scheduler such as OAR [START_REF] Capit | A batch scheduler with high level components[END_REF]. Concerning Slurm integration and extensions our goal is to include our new developments within the ocial future Slurm releases. In an eort to simplify this integration we would like to study and evaluate the layouts framework 5 which seems adapted to our need for exibility in the representation of the infrastructure along with the usage of the layouts API within our algorithms.

Figure 1 :

 1 Figure 1: Tree topology of 6 nodes of 2 processing units with one unavailable nodes: n3

Figure 2 :

 2 Figure2: Example of TreeMatch output (green square) based on the anity matrix and the tree topology. The rst line is without constraints: in this case the hop-byte metric is 360. The second line is when only cores with even numbers are allowed to execute processes (hop-bye is 660 in this case)

Figure 3 :

 3 Figure 3: TreeMatch measured time vs. modeled time for the minighost application with a communication ratio between 5% and 45%

Figure 4 :

 4 Figure 4: Workload Metrics for the dierent strategies and dierent amount of communication ratio

  3.

Figure 4 (

 4 Figure 4(b) also shows that for the same submission workload, TreeMatch improved the resource utilization.

Figure 6 :

 6 Figure 6: Statistical comparison of selection methods: runtime

Figure 7 :

 7 Figure 7: Average owtime of dierent simulations using the Curie trace with dierent strategies and various percentage of communication

https://www.open-mpi.org/projects/netloc RR n°8859

http://www-hpc.cea.fr/en/complexe/tgcc-curie.htm Inria

http://www.cs.huji.ac.il/labs/parallel/workload/ Inria

http://www.schedmd.com/slurmdocs/SLUG15/slurm_layouts_framework.pdf RR n°8859

avenue de la Vieille Tour 33405 Talence Cedex Publisher Inria Domaine de Voluceau -Rocquencourt BP 105 -78153 Le Chesnay Cedex inria.fr ISSN 0249-6399

Acknowledgments

Experiments presented in this paper were carried out using the Grid'5000 testbed, supported by a scientic interest group hosted by Inria and including CNRS, RENATER and several Universities


Avril Treille

Emmanuel Coriandre

Sonia Vilain

Marc Kandel

Sato

Coriandre Vilain

Sonia Kandel

Marc Sato

Seeing our own voice: an electrophysiological study of audiovisual speech integration during self perception

scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

Introduction

To recognize one's own face and voice is key for our self-awareness and for our ability to communicate effectively with others. Interestingly, recent studies suggest that better recognition of one's actions may result from the integration of sensory inputs with our own sensory-motor knowledge. However, whether hearing our voice and seeing our articulatory gestures facilitate audiovisual speech integration is still debated.

 Participants 18 healthy adults, right-handed native French speakers.

 Stimuli

 Syllables : /pa/, /ta/, /ka/  Modalities : auditory (A), visual (V), audio-visual (AV) and incongruent audio-visual (AVi, self auditory signal, other visual signal)

 Half of the stimuli were related to the participant (self condition), the other half to an unknown speaker (other condition).

 A total of 1176 stimuli were created  Tasks 1) Before experiment, a short training was performed.

3) EEG session : a three-alternative forced-choice identification task, with participants instructed to categorize each perceived syllable with their right hand, after an audio "beep".

 Data acquisition

 EEG data were continuously recorded from 64 scalp electrodes (international 10-20 system) using the Biosemi ActiveTwo AD-box EEG system operating at a sampling rate of 256 Hz.

 Two additional electrodes served as reference [CMS] & [DRL]

 One other external reference electrode was at the top of the nose. The electrooculogram controlling for horizontal (HEOG) and vertical (VEOG) eye movements were recorded using electrodes at the outer canthus of each eye as well as above and below the right eye. Before the experiment, the impedance of each electrode was adjusted to get low offset voltage and stable DC.

 Analysis

 Behavioral analyses:

 EEG analyses on fronto-central electrodes (F3/F4/C3/C4/Fz/Cz):

 Correlation between EEG and behavioral data

Correlations between Integration (EEG; AV-A+V) & Visual identification (%)

Methods

Results

Discussion 1) Behavioral results : All modality was perfectly perceived except in the visual modality. /pa/ was better perceived than /ta/ and /ka/ during visual presentation.

2) Integration for both self and other signals : Early integration processing (on P2) during AV-self and AV-other speech perception compared to A+V.

3) Speaker effect on N1 latency : Compared to Visual-other, Visual-self stimuli induced a temporal facilitation on N1 during integration mechanisms. 4) Correlations on N1 latency for self visually ambiguous syllables : A negative correlation was oberved between visual-self identificcation and integration results on N1.

=> In line with previous EEG studies on multimodal speech perception, our results point to the existence of early integration mechanisms of auditory and visual speech information. Crucially, they also provide evidence for a processing advantage when the perceptual situation involves our own speech productions mostly for visually ambiguous syllables. Viewing our own utterances leads to a temporal facilitation of the integration of auditory and visual speech signals. Correlation -N1 Amplitude

V-self V-other -7 -2 3 50% 60% 70% 80% 90% 100%
Correlation -P2 Amplitude • Visual-Self : reduced N1 latency (p<.02)

• P2 amplitude : AV < A+V (p<. 02)

• => integration

  type (Bimodal/Sum), Auditory modality (Self/Other), Visual modality (Self/Other) ANOVA : Signal type (Bimodal/Sum), Auditory modality (Self/Other), Visual modality (Self/Other) Part of this research was supported by a grant from the European Research Council (FP7/2007-2013 Grant Agreement no. 339152, "Speech Unit(e)s") Correspondence: avril.treille@gipsa-lab.inpg.fr 1) Behavioral -% correct responses (p<.001)

self A-other AV-self AV-other AVi-self Avi-other V-self V-other % of correct responses

	60% 65% 70% 75% 80% 85% 90% 95% 100%	Ta Ka A-Pa	• A = AV = Avi > V • /pa/ = /ta/ = /ka/ speaker except for V-self and V-other • No effect of the	-5 -4 -3 -2 -1 4 3 0 1 2																						AsVs As+Vs	-5 -4 -3 -2 -1 4 3 0 1 2																				AoVs Ao+Vs
										5																							5
											-500	-453	-406	-359	-313	-266	-219	-172	-125	-78	-31	16	63	109	156	203	250	297	344	391	438	484		-500	-453	-406	-359	-313	-266	-219	-172	-125	-78	-31	16	63	109	156	203	250	297	344	391	438	484
										-5																							-5
										-4																							-4
										-3																							-3
										-2																							-2
	NS		r=.41, p<.02	Correlation -N1 Latency	-1																							-1
			10 30 50							0 1 2																						AsVo As+Vo	0 1 2																				AoVo Ao+Vo
			-50 -10 -30 50%	60%	70%	80%	90% 100%	V-self V-other	3 4 5	-500	-453	-406	-359	-313	-266	-219	-172	-125	-78	-31	16	63	109	156	203	250	297	344	391	438	484	3 4 5	-500	-453	-406	-359	-313	-266	-219	-172	-125	-78	-31	16	63	109	156	203	250	297	344	391	438	484
	NS		NS	Correlation -P2 Latency
			50
			30
		V-self V-other	-30 10 -10						V-self V-other
			-50
			50% 60% 70% 80% 90% 100%
		-Amplitude N1 & P2 : No efffect -Latence P2 : No effetc -Latence N1 : Self : r=.41, p<.02; other : r=.01, p<.94	• Self : N1 latency is negatively correlated with visual saliency


Coriandre Vilain

Avril Treille

Marc Sato

ELECTROPHYSIOLOGICAL EVIDENCE FOR AUDIO-VISUO-LINGUAL SPEECH INTEGRATION

Introduction

Audio-visual speech perception is a special case of multisensory processing that interfaces with the linguistic system. One important issue is whether cross-modal interactions only depend on well-known auditory and visuo-facial modalities or, rather, might also be triggered by other sensory sources less common in speech communication. The present EEG study aimed at investigating cross-modal interactions not only between auditory, visuo-facial and audio-visuo-facial syllables but also between auditory, visuo-lingual and audio-visuo-lingual syllables.  Method 1) Before the experiment, short explanations on the ultrasound system and tongue movements required for the production of /pa/, /ta/ and /ka/ syllables were given.

2) Behavioral session: a three-alternative forced-choice identification task, with participants instructed to categorize as quickly as possible each perceived syllable with their right hand.

3) EEG session: a three-alternative forced-choice identification task, with participants instructed to categorize each perceived syllable with their right hand, after an audio "beep".

 Data acquisition  EEG data were continuously recorded from 64 scalp electrodes (international 10-20 system) using the Biosemi ActiveTwo AD-box EEG system operating at a sampling rate of 256 Hz.

 Two additional electrodes served as reference [CMS] & [DRL]

 One other external reference electrode was at the top of the nose. The electrooculogram controlling for horizontal (HEOG) and vertical (VEOG) eye movements were recorded using electrodes at the outer canthus of each eye as well as above and below the right eye. Before the experiment, the impedance of each electrode was adjusted to get low offset voltage and stable DC.

 Analysis

 Behavioral analyses ( 1):

 EEG analyses on fronto-central electrodes (F3/F4/C3/C4/Fz/Cz):

METHODS

 60 stimuli were created consisting of 12 /pa/, /ta/ and /ka/ syllables related to 5 conditions: an auditory condition (A), 2 visual (VL, VT) and 2 audio-visual (AVL, AVT) conditions related to either lip or tongue movements of a speaker.

RESULTS

Discussion 1) Lips > tongue > chance : For the visual-only modality, syllables are perceived correctly even when they refer to tongue movement.

2) Noise vs No Noise : In line with previous studies, adding noise reduces and shifts the N1/P2 peaks.

3) Integration : Early integration processing (on P2) during AV-lips and AVT-tongue speech perception compared to A+V. 4) Difference between lips and tongue audio-visual speech perception : an amplitude difference (N1 is smaller and P2 is larger than N1/P2 observed during AV-lips perception) => Although participants were not experienced with visuo-lingual stimuli, our results demonstrate that they were able to recognize them and provide the first evidence for audio-visuo-lingual speech interactions. These results further emphasize the multimodal nature of speech perception and likely reflect the impact of listener's knowledge of speech production on speech perception.

% of correct responses



  Participants 18 healthy adults, right-handed native French speakers.  Stimuli  /pa/, /ta/ and /ka/ syllables were individually recorded by one male and one female speakers in a sound-proof room. Two /pa/, /ta/ and /ka/ tokens were selected per speaker .  Synchronous recordings of auditory, visual and ultrasound lingual signals were acquired by a Terason T3000 ultrasound system (UltraSpeech system, Hueber et al. 2008) .

  referenced off-line to the nose -Filtering : 1-30 Hz -Epochs : 1000ms (baseline from -500 to -400ms -Rejection : ±60 µV to the acoustic syllable onset) research was supported by a grant from the European Research Council (FP7/2007-2013 Grant Agreement no. 339152, "Speech Unit(e)s") Correspondence: avril.treille@gipsa-lab.inpg.fr

  A+V : Lips (258ms); Tongue (248ms) AV : Lips (248ms); Tongue (244ms) TR : Main Effects: -Noise > No Noise (p<.03) -A=AV < V (p<.0001) Interactions: -Noise: A = AV = V No noise: A = AV < V (p<.0001) -Lips: A = V > AV Tongue: A = AV < V (p<.01) Simultaneous recording : left : tongue movements with ultrasound system; right : Lips movements with camera

-average (AL, AVL, AT, AVT in noise and no noise conditions)

  1) N1 and P2 latency and amplitude analysis by ANOVA with Environment (Noise/No noise), Articulator (Lips/Tongue) and Modality (A, AV) as intra-subject variable (main effects and interactions)  2) N1 and P2 latency and amplitude were also tested for integration, i.e. an ANOVA with Environment (Noise/No noise),

																																								Articulator (Lips/Tongue), Signal type (Bimodal (AV)/Sum (A+V)) as intra-subject variable (main effects and interactions)
		100%
		90%
		80%
		70%
		60%
		50%
		40%
					AL		AVL		VL		AT		AVT		VT
																																								N1/P2 Lips N1
	-1,50																																							Tongue
																																						A+V
	-1,00																							N1													AV
	-0,50
	0,00
	0,50
	1,00																																							P2
	1,50																																					-500	-469	-438	-406	-375	-344	-313	-281	-250	-219	-188	-156	-125	-94	-63	-31	0	31	63	94	125	156	188	219	250	281	313	344	375	406	438	469
	2,00	-500	-473	-445	-418	-391	-363	-336	-309	-281	-254	-227	-199	-172	-145	-117	-90	-63	-35	-8	20	47	74	102	129	156	184	211 P2	238	266	293	320	348	375	402	430	457	484		• For tongue (compared to lips) : (p<.01) Reduced N1 amplitude
																																								•	Larger P2 amplitude
																																								(p<.0001)




Avril Treille

Emmanuel Coriandre

Sonia Vilain

Jean-Luc Kandel

Marc Schwartz

Sato

Speech in the mirror? Neurobiological correlates of self speech perception

à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

The same stimuli were used for both experiments :

• Syllables : /pa/, /ta/, /ka/ • Modalities : auditory (A), visual (V), audio-visual (AV) and incongruent audiovisual (AVi, self auditory signal dubbing other visual signal)

• Half of the stimuli were related to the participant (self condition), the other half to an unknown speaker (other condition).

• A total of 1176 stimuli were created

• Subjects:

• EEG: 18 healthy adults, right-handed native French speakers.

• fMRI: 12 healthy adults, right-handed native French speakers.

• Task: three-alternative forced-choice identification task, with participants instructed to categorize each perceived syllable with their left hand, after an audio "beep".

• Data acquisition: EEG data were continuously recorded from 64 scalp electrodes (international 10-20 system) using the Biosemi EEG system operating at a sampling rate of 256 Hz. External reference electrode was at the top of the nose. The electrooculograms controlling for horizontal (HEOG) and vertical (VEOG) eye movements were recorded using electrodes at the outer canthus of each eye as well as above and below the right eye.

• Data pre-processing : EEG-Lab

(1) Re-referenced off-line to the nose;

(2) Filtering: 2-30 Hz;

(3) Epoching: 1000ms (baseline from -500 to -400ms to the acoustic syllable onset);

(4) Artifact Rejection: ±60 µV

• Data analyses:

• Task: passive listening and/or viewing of A, V, AV or Avi /pa/, /ta/, and /ka/ syllables (+ a resting face of the participant of the unknown speaker serving as baseline). The stimuli were presented with (-6 dB SNR) or without acoustic noise.

• Data recording: 3T whole-body MR scanner (Philips Achieva TX) using a sparse sampling acquisition in order to minimize scanner noise during speech perception (53 axial slices, 3 mm3; TR = 8 sec, acquisition from the stimulus onset: 5s). T1-weighted whole-brain structural image for each participant after the last functional run (MP-RAGE, sagittal volume of 256 x 224 x 176mm3 with a 1 mm isotropic resolution).

• Data pre-processing: SPM8.

(1) rigid realignment of each EPI volume to the first of the session,

(2) coregistration of the structural image to the mean EPI,

(3) normalization of the structural image to common subject space (with a subsequent affine registration to MNI space) using the group-wise DARTEL registration method, (4) warping of all functional volumes using deformation flow fields generated from normalization step, (5) affine registration for transformation into the Montreal Neurological Institute (MNI) space , (6) spatially smoothing with a three-dimensional Gaussian kernel with a full width at half-maximum of 9 mm.

• Data analyses:

o 1 st level: GLM: 16 regressors of interest (4 modalities (A, V, AV, AVi) x 2 speakers (self, other) x 2 noise (with, without) and six realignment parameters as nuisance regressors, with the 4 corresponding baselines (2 speakers x 2 noise levels) forming an implicit baseline. The BOLD response for each event was modeled using a single-bin finite impulse response (FIR) basis function spanning the time of acquisition (3s) and a high-pass filtering with a cutoff period of 128s was applied.

o 2 nd level: group effect: modality (4 levels: A, V, AV, AVi), the speaker (2 levels: self, other) and the noise (2 levels, without, with) as within-subject factors and the subjects treated as a random factor. Self-awareness and self-recognition during action observation may partly result from a functional matching between action and perception systems. This perception-action interaction is thought to enhance the integration between sensory inputs and our own sensory-motor knowledge.

SPEECH IN THE MIRROR? NEUROBIOLOGICAL CORRELATES OF SELF-SPEECH PERCEPTION

We present a combined EEG and fMRI study that examines the impact of self-knowledge on multisensory integration mechanisms during auditory, visual and audio-visual speech perception. Our working hypothesis was that hearing and/or viewing oneself talk might facilitate the bimodal integration process and activate sensory-motor plans to a greater degree than does observing others.

(1) a) In line with previous studies on multimodal speech perception => integration mechanisms of auditory and visual speech signals.

b) A visual processing advantage when the perceptual situation involves our own speech production.

(2) a) Global coherent activations of the single effects during auditory, visual and audio-visual speech perception.

b) hearing and/or viewing oneself talk increased activation in the left posterior inferior frontal gyrus (pars opercularis) and cerebellum. These regions are generally responsible for predicting sensory outcomes of action generation.

Altogether, these results suggest that viewing our own utterances leads to a temporal facilitation of auditory and visual speech integration and processing afferent and efferent signals in sensory-motor areas gives rise to self-awareness during speech perception.

METHODS

A V AV AVi

Single Effects (T contrasts, p < .05 FWE corrected): brain activity observed in each modality compared to baseline, irrespective of the speaker. Modality results :

EEG

-Auditory regions : stronger activity for the auditory condition than the visual only condition -Visual regions : stronger activity for the visual condition than for the auditory only condition -Greater Activity of the dorsal part of the premotor cortex for visual stimuli (no activation for the auditory only condition)

Self effect :

-Stronger activity of the cerebellum, the parahippocampic gyrus and the left inferior frontal gyrus (pars opercularis) -Small effect but we'll test more subjects * *

  Self x Modality Interaction (F contrast, p < .001 unc)Main Effect of Self (F contrast, p < .001 unc)Self x Noise Interaction(F contrast, p < .001 unc)

  Avril Treille 1 , Coriandre Vilain 1 , Sonia Kandel 1 , Jean-Luc Schwartz 1 & Marc Sato 2

1 GIPSA-lab, Département Parole & Cognition, CNRS & Grenoble Université, Grenoble, France 2 Laboratoire Parole & Langage, CNRS & Aix Marseille Université, France Part of this research was supported by a grant from the European Research Council (FP7/2007-2013 Grant Agreement no. 339152, "Speech Unit(e)s") Correspondence: avril.treille@gipsa-lab.grenoble-inp.fr