Learn More
SmallEiffel is an Eiffel compiler which uses a fast simple type inference mechanism to remove most late binding calls, replacing them by static bindings. Starting from the system's entry point, it compiles only statically living code, which saves compiling and then removing dead code. As the whole system is analyzed at compile time, multiple inheritance and(More)
Software is usually complex and always intangible. In practice, the development and maintenance processes are time-consuming activities mainly because software complexity is difficult to manage. Graphical visualization of software has the potential to result in a better and faster understanding of its design and functionality, thus saving time and providing(More)
The SmallEiiel compiler uses a simple type inference mechanism to translate Eiiel source code to C code. The most important aspect in our technique is that many occurrences of late binding are replaced by static binding. Moreover, when dynamic dispatch cannot be removed, inlining is still possible. The advantage of this approach is that it speeds up(More)
Mark and sweep garbage collectors (GC) are classical but still very efficient automatic memory management systems. Although challenged by other kinds of systems, such as copying collectors, mark and sweep collectors remain among the best in terms of performance.This paper describes our implementation of an efficient mark and sweep garbage collector tailored(More)
Software systems are often very complex because of their huge size and the tremendous number of interactions between their components. However, understanding relations between software elements is crucial to optimize the development and the maintenance process. A good way to ease this understanding of software relations is to use advanced visualization(More)
Reducing memory energy consumption in embedded systems is crucial. In this paper, we propose new sequential and distributed algorithms based on Simulated Annealing (SA) in order to reduce memory energy consumption in embedded systems. Our algorithms outperform the Tabu Search (TS) approach. In fact, our algorithms manage to consume nearly from 76% up to 98%(More)
The design of the Eiffel language makes it possible to perform global optimizations on Eiffel programs. In this paper, we describe some of the techniques we used in SmallEiffel, The GNU Eiffel Compiler, to generate highly efficient executables for Eiffel programs. Most of these techniques — related to global analysis or not — may also be applied to other(More)
Understanding what happens during the runtime of a Java program is difficult. Tracking runtime flow can bring valuable information for program understanding and behavior analysis. Polymorphism, thread concurrency or even simple facts like the number of method invocations and the number of executed bytecodes are valuable information to track, but are(More)