Search

International audience; Efficiently exploiting computational resources in heterogeneous platforms is a real challenge which has motivated the adoption of the task-based programming paradigm where resource usage is dynamic and adaptive. Unfortunately, classical performance visualization techniques used in routine performance analysis often fail to provide any insight in this new context, especially when the application structure is irregular. In this paper, we propose several performance visualization techniques and modeling strategies motivated by the analysis of task-based multifrontal sparse linear solvers whose structure is particularly complex. We show that by building on both a performance model of irregular tasks and on structure of the application (in particular the elimination tree), we can detect and highlight anomalies and understand resource utilization from the application point-of-view in a very insightful way. We validate these novel performance analysis techniques with the QR_mumps sparse parallel solver by describing a series of case studies where we identify and address non trivial performance issues thanks to our visualization methodology.

[ES] Las herramientas de verificación de modelos model checking existentes ofrecen ciertas facilidades para el análisis y comprensión del proceso de verificación de sistemas hardware y software. Este es el caso del verificador algorítmico SPIN, que permite al usuario inspeccionar detalles de la verificación formal a través de interfaces gráficas como las que ofrecen las herramientas iSpin o xSpin. Cuando el intento de verificación de una propiedad falla, dichos sistemas devuelven, a modo de contraejemplo, una traza de su ejecución que demuestra que la propiedad analizada es falsa. Sin embargo, las interfaces actuales ofrecen facilidades de inspección limitadas y su uso requiere unos conocimientos avanzados sobre el diseño de SPIN y de las diferentes configuraciones que el sistema puede soportar. El objetivo de este trabajo es desarrollar una herramienta online que, además de permitir al usuario modelar y verificar en SPIN las propiedades temporales de un sistema, soporte una exploración flexible e interactiva de las ejecuciones del model checker. El entorno estará focalizado en facilitar el aprendizaje del funcionamiento de SPIN y la comprensión de los contraejemplos generados, que pueden ser visualizados en forma gráfica. La herramienta permite al usuario interactuar con dicha representación para ayudarle a comprender las causas de los fallos de verificación. En primer lugar, se ofrece un modo de exploración global que permite a los usuarios obtener una vista general del grafo para comprender su funcionamiento a alto nivel. En segundo lugar, la herramienta soporta un modo de exploración local que permite al programador interactuar con el verificador. Además de permitir el escrutinio de los estados de la traza, el sistema desarrollado ofrece una interfaz de consulta que permite filtrar y destacar regiones específicas del grafo., [EN] Model checking tools currently offer several facilities for the analysis and understanding of the verification process of hardware systems and software systems. This is the case of the algorithmic verifier SPIN, which allows the user to inspect specific details of the formal verification by means of a graphical interface such as the iSpin and xSpin ones. When the attempt to verify a property fails, these systems return, as a useful counterexample, an execution trace showing that the analyzed property is false. However, the current interfaces offer limited inspection facilities, and moreover, their use requires advanced knowledge of the SPIN design and of the configurations it supports The objective of this work is to develop an online tool that, besides supporting the user in modeling and verifying the temporary properties of a system using SPIN, supports the interactive exploration of the model checker executions un a flexible way. The environment is aimed at helping non-expert users learn how to use SPIN and to understand the delivered counterexamples, which can be graphically displayed. The user is allowed to interact with this graphical representation to understand the causes of a verification failure. First, a global inspection mode has been implemented that provides users with a general, high-level overview of the graph. Second, a local inspection mode facilitates the interactive use of the verifier. Besides allowing the trace states to be scrutinized, a query interface is also provided that allows the user to filter and highlight specific regions of the graph., [CA] Les eines de verificació de models existents ofereixen unes certes facilitats per a l’anàlisi i comprensió del procés de verificació de sistemes hardware i software. Aquest és el cas del verificador algorítmic SPIN, que permet a l’usuari inspeccionar detalls de la verificació formal a través d’interfícies gràfiques com les que ofereixen les eines iSpin o xSpin. Quan l’intent de verificació d’una propietat falla, aquests sistemes retornen, a manera de contraexemple, una traça de la seua execució que demostra que la propietat analitzada és falsa. No obstant això, les interfícies actuals ofereixen facilitats d’inspecció limitades i el seu ús requereix uns coneixements avançats sobre el disseny de SPIN i de les diferents configuracions que el sistema pot suportar. L’objectiu d’aquest treball és desenvolupar una eina en línia que, a més de permetre a l’usuari modelar i verificar en SPIN les propietats temporals d’un sistema, suporte una exploració flexible i interactiva de les execucions del model checker. L’entorn estarà focalitzat a facilitar l’aprenentatge del funcionament de SPIN i la comprensió dels contraexemples generats, que poden ser visualitzats en forma gràfica. L’eina permet a l’usuari interactuar amb aquesta representació per a ajudar-lo a comprendre les causes de les fallades de verificació. En primer lloc, s’ofereix una manera d’exploració global que permeta als usuaris obtindre una vista general del graf per a comprendre el seu funcionament a alt nivell. En segon lloc, l’eina suporta una manera d’exploració local que permeta al programador interactuar amb el verificador. A més de permetre l’escrutini dels estats de la traça, el sistema desenvolupat ofereix una interfície de consulta que permet filtrar i destacar regions específiques del graf.

High-performance computing (HPC) applications enable the solution of compute-intensive problems in feasible time. Among many HPC paradigms, task-based programming has gathered community attention in recent years. This paradigm enables constructing an HPC application using a more declarative approach, structuring it in a direct acyclic graph (DAG). The performance evaluation of these applications is as hard as in any other programming paradigm. Understanding how to analyze these applications, employing the DAG and runtime metrics, presents opportunities to improve its performance. This article describes the StarVZ R-package available on CRAN for performance analysis of task-based applications. StarVZ enables transforms runtime trace data into different vi-sualizations of the application behavior. An analyst can understand their applications' performance limitations and compare multiple executions. StarVZ has been successfully applied to several study-cases, showing its applicability in a number of scenarios.

International audience; This paper presents EASYPAP, an easy-to-use programming environment designed to help students to learn parallel programming. EASYPAP features a wide range of 2D computation kernels that the students are invited to parallelize using Pthreads, OpenMP, OpenCL or MPI. Execution of kernels can be interactively visualized, and powerful monitoring tools allow students to observe both the scheduling of computations and the assignment of 2D tiles to threads/processes. By focusing on algorithms and data distribution, students can experiment with diverse code variants and tune multiple parameters, resulting in richer problem exploration and faster progress towards efficient solutions. We present selected lab assignments which illustrate how EASYPAP improves the way students explore parallel programming.

Multi-threading is commonly applied in modern computer programs, bringing many conveniences but also causing concurrency issues. Among the various error debugging tools, Java Pathfinder (JPF) can detect latent errors of multithreaded Java programs through model checking. However, the text-based format of the output trace is hard to read, and previous attempts in visualizing JPF traces show limitations. For long-term development, popular trace analytic platform such as Trace Compass (TC) is extended to adapt to JPF traces. In this thesis, the development of JPF and TC makes it possible to analyze JPF traces on TC with a user interface including visual diagrams. The development solves the conceptual differences between the tools and successfully visualize important trace data. The implementation can help provide a generic approach for analyzing JPF traces with visualization. Multitrådning används ofta i moderna datorprogram, vilket har många fördelar men kan också orsaka samtidighetsproblem. Bland olika felsökningsverktyg kan Java Pathfinder (JPF) upptäcka latenta fel hos multitrådade Javaprogram genom modellkontroll. Spårningsinformationen i form av text har låg läsbarhet, och tidigare försök att visualsera JPF-spår har visat begränsningar. För långsiktig utveckling har populära spårningsanalysplattformar som Trace Compass (TC) utvidgats för att anpassas till JPF-spår. I examensprojektet gör utvecklingen av JPF och TC det möjligt att analysera JPF-spår på TC med ett användargränssnitt baserat på visuella diagram. Utvecklingen löser den konceptuella skillnaden mellan verktygen och visualiserar spårdata på ett framgångsrikt sätt. Implementeringen bidrar med ett generiskt tillvägagångssätt för att analysera JPF spår med hjälp av visualisering.

Programming paradigms in High-Performance Computing have been shifting toward task-based models that are capable of adapting readily to heterogeneous and scalable supercomputers. The performance of task-based applications heavily depends on the runtime scheduling heuristics and on its ability to exploit computing and communication resources. Unfortunately, the traditional performance analysis strategies are unfit to fully understand task-based runtime systems and applications: they expect a regular behavior with communication and computation phases, while task-based applications demonstrate no clear phases. Moreover, the finer granularity of task-based applications typically induces a stochastic behavior that leads to irregular structures that are difficult to analyze. In this thesis, we propose performance analysis strategies that exploit the combination of application structure, scheduler, and hardware information. We show how our strategies can help to understand performance issues of task-based applications running on hybrid platforms. Our performance analysis strategies are built on top of modern data analysis tools, enabling the creation of custom visualization panels that allow understanding and pinpointing performance problems incurred by bad scheduling decisions and incorrect runtime system and platform configuration. By combining simulation and debugging we are also able to build a visual representation of the internal state and the estimations computed by the scheduler when scheduling a new task. We validate our proposal by analyzing traces from a Cholesky decomposition implemented with the StarPU task-based runtime system and running on hybrid (CPU/GPU) platforms. Our case studies show how to enhance the task partitioning among the multi-(GPU, core) to get closer to theoretical lower bounds, how to improve MPI pipelining in multi-(node, core, GPU) to reduce the slow start in distributed nodes and how to upgrade the runtime system to increase MPI bandwidth. By employing simulation and debugging strategies, we also provide a workflow to investigate, in depth, assumptions concerning the scheduler decisions. This allows us to suggest changes to improve the runtime system scheduling and prefetch mechanisms.; Dans le cadre du calcul haute performance, l’utilisation d’un modèle de programmation basé sur un parallélisme de tâche est de plus en plus courant. Cette approche permet de s’adapter plus facilement aux super-ordinateurs utilisant des architectures hybrides. La performance d’applications à bases de tâches dépend fortement des heuristiques d’ordonnancement dynamiques sous-jacente et de leur capacité à exploiter les ressources de calcul et de communication. Malheureusement, les stratégies d’analyse de performance traditionnelles ne sont pas adaptées à l’analyse de supports d’exécution dynamiques et d’applications basées sur des tâches. Ces stratégies supposent en général un comportement relativement régulier avec des alternances de phases de calcul et de communication alors que les applications basées sur des tâches ne présentent pas de structures aussi précises. Par ailleurs, l’asynchronisme et la granularité plus fine des applications basées sur des tâches induit des comportements stochastiques qui donnent lieu à des structures naturellement irrégulières qui sont difficiles à analyser. Dans cette thèse, nous proposons des stratégies d’analyse de performance qui exploitent à la fois la structure de l’application, des caractéristiques de l’ordonnancement et des informations de la plate-forme. Nous présentons comment nos stratégies peuvent aider à comprendre et résoudre des problèmes de performance non triviaux dans des applications basée sur des tâches qui s’exécutent sur des plates-formes hybrides. Nos stratégies d’analyse de performance sont construites à l’aide d’outils d’analyse de données génériques et modernes, ce qui permet de créer des vues spécifiques et adaptées. Ces vues permettent la compréhension et l’identification de problèmes de performances occasionnés par de mauvaises décisions d’ordonnancement ou bien des configurations incorrectes du support d’exécution et de la plate-forme. En combinant des techniques de simulation et de débogage à des vues spécifiquement développées pour représenter l’état interne de l’ordonnanceur et qui le conduisent à prendre ses décisions, nous avons montré qu’il était possible d’évaluer certaines hypothèses sur la pertinence de ses choix. Nous validons notre proposition en analysant de nombreuses traces d’exécutions d’une factorisation de Cholesky implémenté avec le support d’exécution StarPU et exécutée sur différentes plates-formes hybrides (CPU/GPU). Nos études de cas montrent comment améliorer la partition des tâches entre les différents cœurs et GPUS pour s’approcher des bornes inférieures théoriques, comment améliorer le pipeline des opérations MPI entre les différents nœuds (multi-coeurs et multi-GPUs) pour accélérer le démarrage de l’application, et comment améliorer le support d’exécution pour augmenter la bande passante MPI. L’emploi des stratégies de simulation et débogage, nous fournissons une approche permettant d’examiner, en détail, les décisions d’ordonnancement et ainsi de proposer des améliorations des mécanismes d’ordonnancement et de prefetch du support d’exécution.

No contexto da Computação de Alto Desempenho, a utilização de modelos de programação baseados em paralelismo de tarefas é cada vez mais frequente uma vez que estes são capazes de se adaptar mais facilmente à supercomputadores que utilizam arquiteturas híbridas. O desempenho das aplicações baseadas em tarefas depende fortemente de heurísticas de escalonamento dinâmicas e da habilidade destas em explorar os recursos de computação e comunicação. Infelizmente, as estratégias de análise de desempenho tradicionais não são adequadas à análise de ambientes de execução dinâmicos e de aplicações baseadas em tarefas. Estas estratégias esperam, em geral, um comportamento relativamente regular com alternância de fases de computação e comunicação enquanto as aplicações baseadas em tarefas não apresentam estruturas tão bem definidas. Além disso, o assincronismo e a granularidade mais fina das aplicações baseadas em tarefas induz comportamentos estocásticos que levam à estruturas naturalmente irregulares que são difíceis de analisar. Nesta tese, nós propomos estratégias de análise de desempenho que exploram simultaneamente a estrutura da aplicação, características do escalonador e informações da plataforma. Nós mostramos como nossas estratégias podem ajudar à compreender e resolver problemas de desempenho não triviais em aplicações baseadas em tarefas executadasm em plataformas híbridas. Nossas estratégias de análise de desempenho são construídas sobre ferramentas de análise de dados modernas e genéricas, o que possibilita a criação de visualizações específicas e adaptadas. Estas visualizações permitem a compreensão e a identificação de problemas de desempenho ocasionados por decisões de escalonamento impróprias bem como por configurações incorretas do ambiente de execução e da plataforma. Por meio da combinação de técnicas de simulação e depuração com visualizações especificamente desenvolvidas para representar o estado interno do escalonador e suas estimativas, nós mostramos como é possível avaliar certas hipóteses sobre a pertinência das decisões de escalonamento. Nós validamos nossa propostas por meio da análise de rastros de execução de uma fatorização de Cholesky implementada com o ambiente de execução StarPU e executada com diferentes plataformas híbridas (CPU/GPU). Nossos estudos de caso mostram como melhorar a partição das tarefas entre diferentes núcleos CPU e GPUs para se aproximar dos limites inferiores teóricos, como melhorar o pipeline das operações MPI entre diferentes nós (multicore e multi-GPUs) para acelerar o início da aplicação, e como melhorar o ambiente de execução para aumentar a largura de banda MPI. O emprego de estratégias de simulação e depuração, nos fornece uma abordagem que permite examinar, em detalhes, as decisões de escalonamento bem como de propor melhorias nos mecanismos de escalonamento e prefetch do ambiente de execução. Programming paradigms in High-Performance Computing have been shifting toward taskbased models that are capable of adapting readily to heterogeneous and scalable supercomputers. The performance of task-based applications heavily depends on the runtime scheduling heuristics and on its ability to exploit computing and communication resources. Unfortunately, the traditional performance analysis strategies are unfit to fully understand task-based runtime systems and applications: they expect a regular behavior with communication and computation phases, while task-based applications demonstrate no clear phases. Moreover, the finer granularity of task-based applications typically induces a stochastic behavior that leads to irregular structures that are difficult to analyze. In this thesis, we propose performance analysis strategies that exploit the combination of application structure, scheduler, and hardware information. We show how our strategies can help to understand performance issues of task-based applications running on hybrid platforms. Our performance analysis strategies are built on top of modern data analysis tools, enabling the creation of custom visualization panels that allow understanding and pinpointing performance problems incurred by bad scheduling decisions and incorrect runtime system and platform configuration. By combining simulation and debugging, we are also able to build a visual representation of the internal state and the estimations computed by the scheduler when scheduling a new task. We validate our proposal by analyzing traces from a Cholesky decomposition implemented with the StarPU task-based runtime system and running on hybrid (CPU/GPU) platforms. Our case studies show how to enhance the task partitioning among the multi- (GPU, core) to get closer to theoretical lower bounds, how to improve MPI pipelining in multi-(node, core, GPU) to reduce the slow start in distributed nodes and how to upgrade the runtime system to increase MPI bandwidth. By employing simulation and debugging strategies, we also provide a workflow to investigate, in depth, assumptions concerning the scheduler decisions. This allows us to suggest changes to improve the runtime system scheduling and prefetch mechanisms.

International audience; We present Aftermath, an open source graphical tool designed to assist inthe performance debugging process of task-parallel programs byvisualizing, filtering and analyzing execution traces interactively.To efficiently exploit increasingly complex and concurrent hardwarearchitectures, both the application and the run-time system thatmanages task execution must be highly optimized. However, detectingperformance anomalies is challenging as bottlenecks can arise directlyfrom the application, the run-time or interaction with the hardware.In Aftermath, key metrics and indicators, such as task duration, stateinformation, hardware performance counter values and data exchangescan be visualized jointly, aggregated and related to the machine'stopology. The tool supports traces of up to several gigabytes, withfast and intuitive navigation and on-line generation of new derivedmetrics. As it has proven invaluable to optimize both OpenStream'srun-time and applications, we illustrate Aftermath on genuine casesencountered in the OpenStream project.

To efficiently exploit the resources of new many-core architectures, integrating dozens or even hundreds of cores per chip, parallel programming models have evolved to expose massive amounts of parallelism, often in the form of fine-grained tasks. Task-parallel languages, such as OpenStream, X10, Habanero Java and C or StarSs, simplify the development of applications for new architectures, but tuning task-parallel applications remains a major challenge. Performance bottlenecks can occur at any level of the implementation, from the algorithmic level (e.g., lack of parallelism or over-synchronization), to interactions with the operating and runtime systems (e.g., data placement on NUMA architectures), to inefficient use of the hardware (e.g., frequent cache misses or misaligned memory accesses); detecting such issues and determining the exact cause is a difficult task. In previous work, we developed Aftermath, an interactive tool for trace-based performance analysis and debugging of task-parallel programs and run-time systems. In contrast to other trace-based analysis tools, such as Paraver or Vampir, Aftermath offers native support for tasks, i.e., visualization, statistics and analysis tools adapted for performance debugging at task granularity. However, the tool currently does not provide support for the automatic detection of performance bottlenecks and it is up to the user to investigate the relevant aspects of program execution by focusing the inspection on specific slices of a trace file. In this paper, we present ongoing work on two extensions that guide the user through this process., Comment: Presented at 1st Workshop on Resource Awareness and Adaptivity in Multi-Core Computing (Racing 2014) (arXiv:1405.2281)

An important issue in software evolution is the time and effort needed to understand existing applications. Reverse engineering software to recover behavioural models is difficult and is complicated due to the lack of a standardized way of extracting and visualizing knowledge. In this thesis, we study a technique for automatically extracting static and dynamic data from software, filtering and analysing the data, and visualizing the behavioural model of a selected feature of a software application. We also investigate the usefulness of the generated diagrams as documentation for the software. We present a literature review of studies that have used static and dynamic data analysis for software comprehension. A set of criteria is created, and each approach, including this thesis’ technique, is compared using those criteria. We propose an approach to simplify lengthy traces by filtering out software components that are too low level to give a high-level picture of the selected feature. We use static information to identify and remove small and simple (or uncomplicated) software components from the trace. We define a utility method as any element of a program designed for the convenience of the designer and implementer and intended to be accessed from multiple places within a certain scope of the program. Utilityhood is defined as the extent to which a particular method can be considered a utility. Utilityhood is calculated using different combinations of selected dynamic and static variables. Methods with high utilityhood values are detected and removed iteratively. By eliminating utilities, we are left with a much smaller trace which is then visualized using the Use Case Map (UCM) notation. UCM is a scenario language used to specify and explain behaviour of complex systems. By doing so, we can identify the algorithm that generates a UCM closest to the mental model of the designers. Although when analysing our results we did not identify an algorithm that was best in all cases, there is a trend in that three of the best four algorithms (out of a total of eight algorithms investigated) used method complexity and method lines of code in their parameters. We also validated the algorithm results by doing a comparison with a list of methods given to us by the creators of the software and doing precision and recall calculations. Seven out of the eight participants agreed or strongly agreed that using UCM diagrams to visualize reduced traces is valid approach, with none who disagreed.

High performance applications are composed of many processes that are executed in large-scale systems with possibly millions of computing units. A possible way to conduct a performance analysis of such applications is to register in trace files the behavior of all processes belonging to the same application. The large number of processes and the very detailed behavior that we can record about them lead to a trace size explosion both in space and time dimensions. The performance visualization of such data is very challenging because of the quantities involved and the limited screen space available to draw them all. If the amount of data is not properly treated for visualization, the analysis may give the wrong idea about the behavior registered in the traces. This paper is twofold: first, it details data aggregation techniques that are fully configurable by the user to control the level of details in both space and time dimensions; second, it presents two visualization techniques that take advantage of the aggregated data to scale. These features are part of the Viva open-source tool and framework, which is also briefly described in this paper.; Les applications à hautes performances sont composées d'un grand nombre de processus exécutés sur des systèmes distribués à large échelle comportant potentiellement des millions d'unités de calcul. Une approche possible pour analyser les performance de telles applications consiste à tracer le comportement de chacun des processus individuellement. Le grand nombre de processus ainsi que la complexité de leur comportement conduit à une explosion de la taille de la trace à la fois en terme de temps et d'espace. La visualisation de telles données est extrêmement délicate en raison de la quantité de données impliquées et de la limitation inhérente de l'écran qui interdit que tout afficher. Si les données ne sont pas correctement pre-traitées et agrégées en vue de la visualisation, l'analyse peut être complètement biaisée et induire l'analyste en erreur. Cet article illustre ce problème par un exemple concret avant d'introduire des techniques d'agrégation de données paramétrables et qui permettent à l'analyste de contrôler le niveau de détail auquel il souhaite regarde son système, à la fois dans l'espace et dans le temps. Nous présentons ensuite deux techniques de visualisation tirant parti de cette agrégation paramétrique afin de passer à l'échelle. Ces techniques ont été mises en oeuvre dans l'outil open-source Viva qui est brièvement décrit dans cet article.