Extracting library-based Java applications

Tip, Frank; Sweeney, Peter F.; Laffra, Chris

doi:10.1145/859670.859695

Cited by 13 publications

(11 citation statements)

References 11 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Rayside et al [RK02], Jax [TSL03] and the ExoVM System [Tit06] propose application extraction tools using these techniques for Java applications. Sallenave et al [SD10] apply RTA to produce smaller .NET assemblies for embedded systems.…”

Section: Static Analysis-based Techniquesmentioning

confidence: 99%

See 1 more Smart Citation

Run-Fail-Grow: Creating Tailored Object-Oriented Runtimes.

Polito¹,

Fabresse²,

Bouraqadi³

et al. 2017

JOT

View full text Add to dashboard Cite

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 objectoriented heap of 11kb. We show how tailoring works on application code, base and third-party libraries even supporting human interaction with user Technology, vol. 16, no. 3, 2017Technology, vol. 16, no. 3, , pages 2:1-36. doi:10.5381/jot.2017 2 · G. Polito, L. Fabresse, N. Bouraqadi, S. Ducasse interfaces. These experiments show memory savings ranging from 95% to 99%.

show abstract

Section: Static Analysis-based Techniquesmentioning

confidence: 99%

“…The majority of the solutions to this problem described in the literature [RK02,TSL03,Tit06,SD10,BO14,Age96] propose to automatically detect and extract useful code, so called tailoring, with static call graph construction [GDDC97] (Section 6). These static approaches present several limitations:…”

Section: Introductionmentioning

confidence: 99%

Run-Fail-Grow: Creating Tailored Object-Oriented Runtimes.

Polito¹,

Fabresse²,

Bouraqadi³

et al. 2017

JOT

View full text Add to dashboard Cite

show abstract

“…Butts [3] has shown that approximately 3% to 16% dead or unreachable code exists in programs. Tip and Sweeney [22,21,23] reduce the size of Java applications by using an application extractor. Like our approach, their aim is to ship only needed class files to a mobile device, cut out never invoked methods, and perform some name compression of the constant pool.…”

Section: Related Workmentioning

confidence: 99%

“Slimming” a Java virtual machine by way of cold code removal and optimistic partial program loading

Wagner

Gal

Franz

2011

Science of Computer Programming

View full text Add to dashboard Cite

a b s t r a c tEmbedded systems provide limited storage capacity. This limitation conflicts with the demands of modern virtual machine platforms, which require large amounts of library code to be present on each client device. These conflicting requirements are often resolved by providing specialized embedded versions of the standard libraries, but even these stripped down libraries consume significant resources.We present a solution for ''always connected'' mobile devices based on a zero footprint client paradigm. In our approach, all code resides on a remote server. Only those parts of applications and libraries that are likely to be needed are transferred to the mobile client device. Since it is difficult to predict statically which library parts will be needed at run time, we combine static analysis, opportunistic off-target linking and lazy code loading to transfer code with a high likelihood of execution ahead of time while the other code, such as exception code, remains on the server and is transferred only on demand. This allows us to perform not only dead code elimination, but also aggressive elimination of unused code.The granularity of our approach is flexible from class files all the way down to individual basic blocks. Our method achieves total code size reductions of up to 95%.

show abstract

“…In previous work [8], we have overridden this classical usage of romization and shown the benefits of going further in the system deployment during romization: the romizer can perform very aggressive customizations on the system if the latter is deployed far enough. In particular, call graph analyses [9] on the threads allow unused parts of the APIs to be removed using library extraction techniques [10,11], and the remainder to be specialized for runtime usage. This results in APIs that are custom-tailored on a per-case basis for the system, and have low memory footprints.…”

Section: Previous Work On Romizationmentioning

confidence: 99%

Application-Driven Customization of an Embedded Java Virtual Machine

Courbot

Grimaud

Vandewalle

et al. 2005

Embedded and Ubiquitous Computing – EUC 2005 Workshops

View full text Add to dashboard Cite

Abstract. Java for embedded devices is today synonym of "embeddable pseudo-Java". Embedded flavors of Java introduce incompatibilities against the standard edition and break its portability rule. In this paper, we introduce a way to embed applications written for Java 2 Standard Edition. The applications are pre-deployed into a virtual Java execution environment, which is analyzed in order to tailor the embedded Java virtual machine according to their runtime needs. Experiments reveal that this method produces customized virtual machines that are comparable in size to existing embedded Java solutions, while being more flexible and preserving standard Java compatibility.

show abstract

Extracting library-based Java applications

Abstract: Reducing the size of Java applications by creating an application extractor.

Cited by 13 publications

References 11 publications

Run-Fail-Grow: Creating Tailored Object-Oriented Runtimes.

Run-Fail-Grow: Creating Tailored Object-Oriented Runtimes.

“Slimming” a Java virtual machine by way of cold code removal and optimistic partial program loading

Application-Driven Customization of an Embedded Java Virtual Machine

Contact Info

Product

Resources

About