BCS: BYTECODE SPECIALIZATION

BCS is a run-time program specialization technique for Java bytecode. It enables the programmer to dynamically generate programs that are optimized by using run-time information.

Publications

Hidehiko Masuhara and Akinori Yonezawa,
“A Portable Approach to Dynamic Optimization in Run-time Specialization”,                                                                                       In Journal of New Generation Computing, Volume 20, Number 1, November 2001. (28 pages)
○A4 size Postscript file(289kbytes),
○PDF file(221kbytes)
Hidehiko Masuhara and Akinori Yonezawa,
“Run-time Bytecode Specialization: A Portable Approach to Generating Optimized Specialized Code”,
In Olivier Danvy and Andrzej Filinski eds., Second Symposium on Programs as Data Objects (PADO II), Aarhus, Denmark, LNCS 2053,               pp.138–154, May 2001. (17 pages)
○A4 size Postscript file(231kbytes),
○PDF file(155kbytes)
Hidehiko Masuhara and Akinori Yonezawa, Generating Optimized Residual Code in Run-Time Specialization,
In Technical Report on Partial Evaluation and Program Transformation Day (PE Day’99), Nov., 1999. 20 pages.
○A4 size Postscript file (232k bytes)
○PDF file (173k bytes)
●Hidehiko Masuhara and Akinori Yonezawa, Run-time Program Specialization in Java Bytecode, in Proceedings of the JSSST SIGOOC 1999    Workshop on Systems for Programming and Applications (SPA’99), March 1999, in Japanese.
○gzipped PostScript file
○PDF file

Brief introduction to BCS

Run-time specialization (RTS) is a technique that efficiently generates specialized programs with respect to run-time values. For efficiently generating specialized programs, RTS constructs compiled native code fragments called templates at compile-time, and generates a specialized program by merely copying the templates. The generated programs are, on the other hand, less efficient, since the technique prevents many optimizations.

We propose bytecode specialization (BCS), which generates programs in a bytecode language, and then translates the generated bytecode into native code by using Just-In-Time (JIT) compilers. The advantages of BCS are: (1) efficient specialization processes that are similar to RTS, (2) efficient specialized programs thanks to the optimizations of JIT compilers, and (3) independence of source-to-bytecode compilers and of bytecode-to-native compilers thanks to our proposed binding-time analysis, which directly handles bytecode programs.

Thus far, we have implemented a BCS system for a Java Virtual Machine subset. Our micro-benchmark shows that BCS with JIT compiler generates a specialized program that runs more than 3-fold faster than the one specialized by traditional RTS techniques, and that our specialization process takes only 610 microseconds.

Hidehiko Masuhara. June 10, 1999.