Maybe this:

Guillermo Polito, Luc Fabresse, Noury Bouraqadi, and Stéphane Ducasse. 
Run-Fail-Grow: Creating Tailored Object-Oriented Runtimes

Producing a small deployment version of an application is a challenge because 
static abstractions such as packages cannot anticipate the use of their parts 
at runtime. Thus, an application often occupies more memory than actually 
needed. Tailoring is one of the main solutions to this problem i.e., extracting 
used code units such as classes and methods of an application. However, 
existing tailoring techniques are mostly based on static type annotations. 
These techniques cannot efficiently tailor applications in all their extent 
(e.g., runtime object graphs and metadata) nor be used in the context of 
dynamically-typed languages. We propose a run-fail-grow technique to tailor 
applications using their runtime execution. Run-fail-grow launches (a) a 
reference application containing the original application to tailor and (b) a 
nurtured application containing only a seed with a minimal set of code units 
the user wants to ensure in the final application. The nurtured application is 
executed, failing when it founds missing objects, classes or methods. On 
failure, the necessary elements are installed into the nurtured application 
from the reference one, and the execution resumes. The nurtured application is 
executed until it finishes, or until the developer explicitly finishes it, for 
example in the case of a web application. resulting in an object memory (i.e., 
a heap) with only objects, classes and methods required to execute the 
application. To validate our approach we implemented a tool based on Virtual 
Machine modifications, namely Tornado. Tornado succeeds to create very small 
memory footprint versions of applications e.g., a simple object-oriented heap 
of 11kb. We show how tailoring works on application code, base and third-party 
libraries even supporting human interaction with user G. interfaces. These 
experiments show memory savings ranging from 95\% to 99\%.

> yes, Mariano Peck made a PhD on that (when we were exploring “how to get 
> smaller images” possibilities).
> We finally went for bootstrap, but we made an analysis on all possibilities 
> around.

Mariano was doing swapping out… 

Mariano Martinez Peck, Noury Bouraqadi, Marcus Denker, Stéphane Ducasse, and 
Luc Fabresse. Marea: An Efficient Application-Level Object Graph Swapper. 

Abstract During the execution of object-oriented applications, several millions 
of objects are created, used and then collected if they are not referenced. 
Problems appear when objects are unused but cannot be garbage-collected because 
they are still referenced from other objects. This is an issue because those 
objects waste primary memory and applications use more primary memory than they 
actually need. We claim that relying on the operating system's (OS) virtual 
memory is not always enough since it cannot take into account the domain and 
structure of applications. At the same time, applications have no easy way to 
parametrize nor cooperate with memory management. In this paper, we present 
Marea, an efficient application-level object graph swapper for object-oriented 
programming languages. Its main goal is to offer the programmer a novel 
solution to handle application-level memory. Developers can instruct our system 
to release primary memory by swapping out unused yet referenced objects to 
secondary memory. Our approach has been qualitatively and quantitatively 
validated. Our experiments and benchmarks on real-world applications show that 
Marea can reduce the memory footprint between 23\% and 36\%.

Reply via email to