Jumbo: run-time code generation for Java and its applications

Kamin, Sam; Clausen, Lars; Jarvis, A.

doi:10.1109/cgo.2003.1191532

Cited by 19 publications

(20 citation statements)

References 5 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Here we show how to accomplish the same effect using strings (see also [14]). Note that in generating a new collection type in Java, one must create two classes: the collection class itself and a class of iterators for that class.…”

Section: Memory Managementmentioning

confidence: 99%

See 1 more Smart Citation

Routine run-time code generation

Kamin

2003

Companion of the 18th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications

View full text Add to dashboard Cite

Run-time code generation (RTCG) would be used routinely if application programmers had a facility with which they could easily create their own run-time code generators, because it would offer benefits both in terms of the efficiency of the code that programmers would produce and the ease of producing it. Such a facility would necessarily have the following properties: it would not require that programmers know assembly language; programmers would have full control over the generated code; the code generator would operate entirely at the binary level. In this paper, we offer arguments and examples supporting these assertions. We briefly describe Jumbo, a system we have built for producing run-time code generators for Java..

show abstract

Section: Memory Managementmentioning

confidence: 99%

“…Imagine that a programmer has available the kind of simple, compile-time code generation facility we have described above. (Most of the code shown here is from [14].) In the simplest version of the problem, the programmer has a piece of code S that is to be repeated, say, 100 times.…”

Section: Efficiency In First-order Programsmentioning

confidence: 99%

Routine run-time code generation

Kamin

2003

Companion of the 18th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications

View full text Add to dashboard Cite

show abstract

“…varlist can_be_defined from temp (12) end (13) (14) feature suminsn (15) variable src1, src2 from temp (16) add src1,src2 to can_be_defined (17) variable dest from can_be_defined (18) remove dest from can_be_defined (19) ${dest} = ${src1} + ${src2}; (20) end (21) (22) feature cpinsn (23) variable src from temp (24) add src to can_be_defined (25) variable dest from can_be_defined (26) remove dest from can_be_defined (27) ${dest} = ${src}; (28) end ( backgroundDist. Depending on the sampled value, the filename from which the background is loaded varies.…”

Section: ${Createimage}mentioning

confidence: 99%

“…Kamin et al [25] created Jumbo, which generates code for Java during the actual running of the program. Poletto et al [26,27] have also added language and compiler support to generate code during runtime.…”

Section: Related Workmentioning

confidence: 99%

A Language and Preprocessor for User-Controlled Generation of Synthetic Programs

Chiu

Garvey

Abdelrahman

2017

Scientific Programming

View full text Add to dashboard Cite

We describe Genesis, a language for the generation of synthetic programs. The language allows users to annotate a template program to customize its code using statistical distributions and to generate program instances based on those distributions. This effectively allows users to generate programs whose characteristics vary in a statistically controlled fashion, thus improving upon existing program generators and alleviating the difficulties associated with ad hoc methods of program generation. We describe the language constructs, a prototype preprocessor for the language, and five case studies that show the ability of Genesis to express a range of programs. We evaluate the preprocessor's performance and the statistical quality of the samples it generates. We thereby show that Genesis is a useful tool that eases the expression and creation of large and diverse program sets.

show abstract

“…String-based multistage languages support true recursion and cooperation between levels, but offer no syntactic guarantees on the generated code; the most widely used are the various shell interpreters, and the current version of the X language is also of this kind. To increase productivity, structured multistage languages enforce syntactic correctness of the generated code: e.g., C++ expression templates [25], 'C [19] and Jumbo [12]. To further increase productivity and ease debugging, a few multistage languages guarantee that the generated code will not produce any compilation error (syntax, definition and initialization errors, type checking): e.g., MetaML and its successor MetaOCaml [2,24].…”

Section: Related Workmentioning

confidence: 99%

A Language for the Compact Representation of Multiple Program Versions

Donadio

Brodman

Roeder

et al. 2006

Languages and Compilers for Parallel Computing

View full text Add to dashboard Cite

Abstract. As processor complexity increases compilers tend to deliver suboptimal performance. Library generators such as ATLAS, FFTW and SPIRAL overcome this issue by empirically searching in the space of possible program versions for the one that performs the best. Empirical search can also be applied by programmers, but because they lack a tool to automate the process, programmers need to manually re-write the application in terms of several parameters whose best value will be determined by the empirical search in the target machine. In this paper, we present the design of an annotation language, meant to be used either as an intermediate representation within library generators or directly by the programmer. This language that we call X represents parameterized programs in a compact and natural way. It provides an powerful optimization framework for high performance computing.

show abstract

Jumbo: run-time code generation for Java and its applications

Cited by 19 publications

References 5 publications

Routine run-time code generation

Routine run-time code generation

A Language and Preprocessor for User-Controlled Generation of Synthetic Programs

A Language for the Compact Representation of Multiple Program Versions

Contact Info

Product

Resources

About