Runtime specialization with optimistic heap analysis

Shankar, Ajeet; Sastry, Shivakumar; Bodík, Rastislav; Smith, James E.

doi:10.1145/1103845.1094837

Cited by 16 publications

(23 citation statements)

References 37 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…If their specializer is used for the example program in Figure 1, it would create a specialized loop for the case of either OPC==ADD or OPC==FOR, but not both. Shankar et al overcome this limitation by creating a specialized loop for each of the hot values observed in the original loop [25]. When applied to the program in Figure 1, they create two specialized loops: for both OPC==ADD and OPC==FOR.…”

Section: Benefits Of Pattern Based Loop Specializationmentioning

confidence: 99%

“…However, IPLS detect patterns before specializing codes, so IPLS can reduce dispatching overheads. In addition, while Shankar et al [25] rely on strong type systems of Java to optimize program with possible heap constants, IPLS can specialize programs written in C language without type system supports. Bolz et al and Yermolovich et al propose Just-In-Time compilers which are optimized to the specific requirements of extracting performance benefits from script interpreters [6,28].…”

Section: Related Workmentioning

confidence: 99%

“…Existing specializers resort to user annotations to identify those instructions which depend solely on known input [2,8,12,18]. Some specializers [3,25] do not need user annotations. Instead, they use dynamic information to identify constant or hot values and perform specialization at runtime.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Practical automatic loop specialization

Kim

Johnson

et al. 2013

Proceedings of the Eighteenth International Conference on Architectural Support for Programming Languages and Operating Systems

View full text Add to dashboard Cite

Program specialization optimizes a program with respect to program invariants, including known, fixed inputs. These invariants can be used to enable optimizations that are otherwise unsound. In many applications, a program input induces predictable patterns of values across loop iterations, yet existing specializers cannot fully capitalize on this opportunity. To address this limitation, we present Invariant-induced Pattern based Loop Specialization (IPLS), the first fully-automatic specialization technique designed for everyday use on real applications. Using dynamic information-flow tracking, IPLS profiles the values of instructions that depend solely on invariants and recognizes repeating patterns across multiple iterations of hot loops. IPLS then specializes these loops, using those patterns to predict values across a large window of loop iterations. This enables aggressive optimization of the loop; conceptually, this optimization reconstructs recurring patterns induced by the input as concrete loops in the specialized binary. IPLS specializes realworld programs that prior techniques fail to specialize without requiring hints from the user. Experiments demonstrate a geomean speedup of 14.1% with a maximum speedup of 138% over the original codes when evaluated on three script interpreters and eleven scripts each.

show abstract

Section: Benefits Of Pattern Based Loop Specializationmentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

Practical automatic loop specialization

Kim

Johnson

et al. 2013

Proceedings of the Eighteenth International Conference on Architectural Support for Programming Languages and Operating Systems

View full text Add to dashboard Cite

show abstract

“…Recent work specializes execution traces [24], working at the array element level, but such techniques unroll loops and generate linear code [14]. Supposing A[0] and A [3] are uncertain in our example, figure (c) shows the program after trace based specialization .…”

Section: Specialization Creates the Version In (B)mentioning

confidence: 99%

“…Classic solutions include partial evaluation (program specialization) [15,17,24] and memoization. However, they fall short for our purpose.…”

Section: Introductionmentioning

confidence: 99%

Coalescing executions for fast uncertainty analysis

Sumner

Bao

Zhang

et al. 2011

Proceedings of the 33rd International Conference on Software Engineering

View full text Add to dashboard Cite

Uncertain data processing is critical in a wide range of applications such as scientific computation handling data with inevitable errors and financial decision making relying on human provided parameters. While increasingly studied in the area of databases, uncertain data processing is often carried out by software, and thus software based solutions are attractive. In particular, Monte Carlo (MC) methods execute software with many samples from the uncertain inputs and observe the statistical behavior of the output. In this paper, we propose a technique to improve the cost-effectiveness of MC methods. Assuming only part of the input is uncertain, the certain part of the input always leads to the same execution across multiple sample runs. We remove such redundancy by coalescing multiple sample runs in a single run. In the coalesced run, the program operates on a vector of values if uncertainty is present and a single value otherwise. We handle cases where control flow and pointers are uncertain. Our results show that we can speed up the execution time of 30 sample runs by an average factor of 2.3 without precision lost or by up to 3.4 with negligible precision lost.

show abstract

Safe, multiphase bounds check elimination in Java

Gampe¹,

Ronne²,

Niedzielski³

et al. 2010

Softw Pract Exp

View full text Add to dashboard Cite

As part of its type‐safety regime, Java's semantics require precise exceptions at runtime when programs attempt out‐of‐bound array accesses. This paper describes a Java implementation that utilizes a multiphase approach to identifying safe array accesses. This approach reduces runtime overhead by spreading the out‐of‐bounds checking effort across multiple phases of compilation and execution: production of mobile code from source code, just‐in‐time (JIT) compilation in the virtual machine, application method invocations, and the execution of individual array accesses. The code producer uses multiple passes (including common subexpression elimination, load elimination, induction variable substitution, speculation of dynamically verified invariants, and inequality constraint analysis) to identify unnecessary bounds checks and prove their redundancy. During class‐loading and JIT compilation, the virtual machine verifies the proofs, inserts code to dynamically validate speculated invariants, and generates code specialized under the assumption that the speculated invariants hold. During each runtime method invocation, the method parameters and other inputs are checked against the speculated invariants, and execution reverts to unoptimized code if the speculated invariants do not hold. The combined effect of the multiple phases is to shift the effort associated with bounds‐checking array access to phases that are executed earlier and less frequently, thus, reducing runtime overhead. Experimental results show that this approach is able to eliminate more bounds checks than prior approaches with minimal overhead during JIT compilation. These results also show the contribution of each of the passes to the overall elimination. Furthermore, this approach increased the speed at which the benchmarks executed by up to 16%. Copyright © 2010 John Wiley & Sons, Ltd.

show abstract

Runtime specialization with optimistic heap analysis

Cited by 16 publications

References 37 publications

Practical automatic loop specialization

Practical automatic loop specialization

Coalescing executions for fast uncertainty analysis

Safe, multiphase bounds check elimination in Java

Contact Info

Product

Resources

About