97 research outputs found
Comparing Rapid Type Analysis with Points-To Analysis in GraalVM Native Image
Whole-program analysis is an essential technique that enables advanced
compiler optimizations. An important example of such a method is points-to
analysis used by ahead-of-time (AOT) compilers to discover program elements
(classes, methods, fields) used on at least one program path. GraalVM Native
Image uses a points-to analysis to optimize Java applications, which is a
time-consuming step of the build. We explore how much the analysis time can be
improved by replacing the points-to analysis with a rapid type analysis (RTA),
which computes reachable elements faster by allowing more imprecision. We
propose several extensions of previous approaches to RTA: making it parallel,
incremental, and supporting heap snapshotting. We present an extensive
experimental evaluation of the effects of using RTA instead of points-to
analysis, in which RTA allowed us to reduce the analysis time for Spring
Petclinic, a popular demo application of the Spring framework, by 64% and the
overall build time by 35% at the cost of increasing the image size due to the
imprecision by 15%
Alias-free Parameters in C for Better Reasoning and Optimization
Aliasing among formal parameters and among formals and globals causes problems for both reasoning and optimization. Whole-program static analysis could provide some knowledge about such aliasing, but this is not usually done, and in any case would have to be conservative. All aliasing patterns that are not ruled out by an analysis have to be considered possible both by a person reasoning about correctness and by a compiler trying to optimize code. For compilers, the conservative nature of the static analysis leads to missed optimization opportunities. We have designed and implemented a small extension to C that partially solves the reasoning problem and leads to significantly better optimization. The extension guarantees that there will be no direct aliasing among arguments and globals inside procedure bodies, and yet allows aliasing among arguments and globals at the call site. This is done by having multiple bodies for each procedure, up to one for each aliasing pattern. Procedure calls are automatically dispatched to the body that matches the run-time aliasing pattern among the actual parameters and the globals. We present experimental evidence that this approach is practical. It is easy to convert existing C code, because not every procedure in a program has to be converted, and because converted code can call code that has not been converted and vice versa. By following simple guidelines, one can convert a program in a way that usually makes it run faster than before. In our experiments with 6 of the SPEC 2000 integer benchmarks we found an average speedup of about 5%. In one case, we had a speedup of about 29%
Tuning an HCI Curriculum for Master Students to Address Interactive Critical Systems Aspects
International audienceThis paper presents the need for specific curricula in order to address the training of specialists in the area of Interactive Critical Systems. Indeed, while curricula are usually built in order to produce specialists in one discipline (e.g. computer science) dealing with systems or products requires training in multiple disciplines. The area of Interactive Critical Systems requires deep knowledge in computer science, dependability, Human-Computer Interaction and safety engineering. We report in this paper how these various disciplines have been integrated in a master program at Université Toulouse III, France and highlight the carrier paths followed by the graduated students and how these carriers are oriented towards aeronautics and space application domains
Las ontologías en la ingeniería de software: un acercamiento de dos grandes áreas del conocimiento
Los conceptos ontológicos se suelen acercar más a la ingeniería del conocimiento, por lo que los ingenieros del software no los suelen aplicar para resolver problemas de su área. Es necesario que los ingenieros de software se apropien de las ontologías, pues éstas proporcionan un vocabulario común, que podría contribuir en la solución de problemas recurrentes en ingeniería del software, tales como la dificultad de la comunicación entre analista e interesado para definir los requisitos de un sistema, la baja reutilización de componentes y la escasa generación automática de código, entre otros. En este artículo se presenta un primer enlace entre las ontologías y la ingeniería de software mediante la recopilación y análisis de la literatura relativa a la utilización de las ontologías en las diferentes fases del ciclo de vida de un producto de software
Achieving High Performance and High Productivity in Next Generational Parallel Programming Languages
Processor design has turned toward parallelism and heterogeneity
cores to achieve performance and energy efficiency. Developers
find high-level languages attractive because they use abstraction
to offer productivity and portability over hardware complexities.
To achieve performance, some modern implementations of high-level
languages use work-stealing scheduling for load balancing of
dynamically created tasks. Work-stealing is a promising approach
for effectively exploiting software parallelism on parallel
hardware. A programmer who uses work-stealing explicitly
identifies potential parallelism and the runtime then schedules
work, keeping otherwise idle hardware busy while relieving
overloaded hardware of its burden.
However, work-stealing comes with substantial overheads. These
overheads arise as a necessary side effect of the implementation
and hamper parallel performance. In addition to runtime-imposed
overheads, there is a substantial cognitive load associated with
ensuring that parallel code is data-race free. This dissertation
explores the overheads associated with achieving high performance
parallelism in modern high-level languages.
My thesis is that, by exploiting existing underlying mechanisms
of managed runtimes; and by extending existing language design,
high-level languages will be able to deliver productivity and
parallel performance at the levels necessary for widespread
uptake.
The key contributions of my thesis are: 1) a detailed analysis of
the key sources of overhead associated with a work-stealing
runtime, namely sequential and dynamic overheads; 2) novel
techniques to reduce these overheads that use rich features of
managed runtimes such as the yieldpoint mechanism, on-stack
replacement, dynamic code-patching, exception handling support,
and return barriers; 3) comprehensive analysis of the resulting
benefits, which demonstrate that work-stealing overheads can be
significantly reduced, leading to substantial performance
improvements; and 4) a small set of language extensions that
achieve both high performance and high productivity with minimal
programmer effort.
A managed runtime forms the backbone of any modern implementation
of a high-level language. Managed runtimes enjoy the benefits of
a long history of research and their implementations are highly
optimized. My thesis demonstrates that converging these highly
optimized features together with the expressiveness of high-level
languages, gives further hope for achieving high performance and
high productivity on modern parallel hardwar
Generic Go to Go: Dictionary-Passing, Monomorphisation, and Hybrid
Go is a popular statically-typed industrial programming language. To aid the
type safe reuse of code, the recent Go release (Go 1.18) published on 15th
March 2022 includes bounded parametric polymorphism via generic types. Go 1.18
implements generic types using combination of monomorphisation and call-graph
based dictionary-passing called hybrid. This hybrid approach can be viewed as
an optimised form of monomorphisation that statically generates specialised
methods and types based on possible instantiations. A monolithic dictionary
supplements information lost during monomorphisation, and it is structured
according to the program's call graph. Unfortunately, the hybrid approach still
suffers from code bloat, poor compilation speed, and limited code coverage.
In this paper we propose and formalise a new non-specialising call-site based
dictionary-passing translation. Our call-site based translation creates
individual dictionaries for each type parameter, with dictionary construction
occurring in place of instantiation, overcoming the limitations of hybrid. We
prove it correct using a novel and general bisimulation up to technique. To
better understand how different generics translations approaches work in
practice, we benchmark five translators, Go 1.18, two existing monomorphisation
translators, our dictionary-passing translator, and erasure translator. Our
findings reveal several suggestions for improvements for Go 1.18 --
specifically how to overcome the expressiveness limitations of generic Go, and
improve compile time and compiled code size performance of Go 1.18.Comment: Full version of paper submitted to OOPSLA '2
- …