Héritage multiple | EPFL Graph Search

En informatique, l’héritage multiple est un mécanisme de programmation orientée objet dans lequel une classe peut hériter de comportements et de fonctionnalités de plus d'une super-classe. Il s'oppose à l'héritage simple, dans lequel une classe ne peut hériter que d'une seule super-classe. Il est supporté par certains langages de programmation, par exemple C++, Eiffel ou Python. Pouvant poser des problèmes, d’autres langages comme Ada, C#, Fortran, Java, Objective-C, Ruby, Swift ou Visual Basic ont préféré ne pas le proposer directement. Utilité L'héritage multiple sert à combiner les comportements de plusieurs classes. Selon B. Stroustrup, l'inventeur du langage C++, ce mécanisme est facultatif parce que les problèmes qu'il résout peuvent être résolus par d'autres moyens. Problèmes L'héritage multiple génère parfois des erreurs de compilation. Le principal problème rencontré est la présence de différentes implémentations par les super-classes d'une certaine classe

Qualified Inheritance in Spatio-Temporal Databases

Pier Donini

In a growing number of applications, different complementary views of real-world objects are needed. This is particularly true in spatial modelling - where the designer can propose different geometries for a given spatial object - or, in temporal modelling -where different life cycles can be defined on an object depending on the adopted point of view. A solution to provide multiple representations on objects is to offer a model supporting multiple instantiation, i.e. allowing real world entities to be instantiated in several classes. At the same time, object-oriented languages and object-oriented modelling have become common in computer science (C++ and Java for the former and UML (Rum.,97) for the latter). Hence, oriented-object properties as inheritance, polymorphism and dynamic binding are commonly used and their expressiveness quite naturally exploited. However, classical object-oriented models and languages onlyallow an implicit form of multiple instantiation among an inheritance hierarchy, i.e. an instance of a class is also a member of all its super-classes. In this paper we propose a solution to integrate classical object oriented mechanisms into models handling multiple instantiation and illustrate it on the conceptual model MADS. To achieve this, the dynamic binding mechanism was revisited, through the concept of scope of an instance (awareness of other instances), in order to manage the ambiguities induced by multiple instantiation. Last, providing an operational solution, a set of operators to modify the point of view of an object (determining which of its class instances is considered) and its scope is defined.

2000

Compiling scala for the Java virtual machine

Michel Schinz

Scala is a new programming language developed at EPFL and incorporating the most important concepts of object-oriented and functional languages. It aims at integrating well with the Java and .NET platforms: their respective libraries are accessible without glue code, and the compiler can produce programs for both virtual machines. This thesis focuses on the compilation of two important concepts of Scala : mixin inheritance and run time types. The compilation techniques are presented in the context of the Java virtual machine, but could be adapted easily to other similar environments. Mixin inheritance is a relatively recent form of inheritance, offering new capabilities compared to single inheritance, without the complexity of multiple inheritance. We propose two implementation techniques for mixin inheritance: code copying and delegation. The implementation used in the Scala compiler is then presented and justified. Run time types make it possible for a program to examine the type of its values during execution. This possibility is interesting in itself, offering new capabilities to the programmer. Furthermore, run time types are also required to implement other high level concepts, like pattern matching, type-safe serialisation and reflection. We propose an implementation technique based on the representation of types as values, and show how to use the run time types of the underlying virtual machine to implement those of Scala. The techniques presented in this thesis have been implemented in our Scala compiler, scalac. This enabled us to evaluate these techniques, in particular their impact on the performances of programs. This evaluation was performed on several real, non-trivial programs.

EPFL2005

Just-in-time performance without warm-up

Denys Shabalin

Scala has been developed as a language that deeply integrates with the Java ecosystem. It offers seamless interoperability with existing Java libraries. Since the Scala compiler targets Java bytecode, Scala programs have access to high-performance runtimes including the HotSpot virtual machine. HotSpot provides impressive performance results achieved via just-in-time compilation. It starts program execution in interpreter mode, collecting profile feedback about called methods. This information allows HotSpot to identify hot spots in the program, which are then compiled on the fly to native code. This compilation scheme enables high peak performance at the cost of warmup time required to collect the profile data and perform just-in-time compilation. This is a good example of the traditional tradeoff between ahead-of-time (AOT) and just-in-time (JIT) compilation. With AOT, compilers have less information, but the runtime story is reasonably straightforward. With JIT, compilers have more information, which enables advanced optimizations, but the runtime story becomes complicated. In this dissertation, we present the design and implementation of Scala Native, an optimizing compiler for Scala. With Scala Native, Scala programs are compiled ahead of time, which avoids runtime compilation and enables instant startup times. On the other hand, Scala Native is able to match and supersede the peak performance of HotSpot on our benchmarks. In addition to that, Scala Native is a general-purpose Scala compiler - programs compiled by Scala Native closely match the behavior of programs compiled by the Scala compiler. First, we introduce NIR, an intermediate representation designed with ahead-of-time compilation in mind. NIR represents programs in the single-static assignment form and has support for object-oriented features such as virtual dispatch and multiple inheritance. This representation is a key enabler of our compilation and optimization pipeline. Secondly, we present Interflow, a link-time optimizer that takes advantage of the closed-world assumption to optimize the whole program at once. Our optimizer employs a number of techniques including partial evaluation, allocation sinking, and method duplication. The combination of these techniques allows Scala Native to outperform HotSpot on the majority of our benchmarks. Finally, we describe how to improve runtime performance even further based on profile feedback. We propose a technique that splits methods apart isolating key hot paths that are then optimized more aggressively than the cold parts of the program. This provides a further performance advantage over HotSpot.

EPFL2020

Just-in-time performance without warm-up

Denys Shabalin

EPFL2020