• Documents
  • Authors
  • Tables
  • Log in
  • Sign up
  • MetaCart
  • DMCA
  • Donate

CiteSeerX logo

Advanced Search Include Citations
Advanced Search Include Citations

Adaptive Optimization for SELF: Reconciling High Performance with Exploratory Programming. (1994)

by U Holzle
Add To MetaCart

Tools

Sorted by:
Results 1 - 10 of 107
Next 10 →

Optimization of Object-Oriented Programs using Static Class Hierarchy Analysis

by Jeffrey Dean, David Grove, Craig Chambers , 1995
"... Abstract. Optimizing compilers for object-oriented languages apply static class analysis and other techniques to try to deduce precise information about the possible classes of the receivers of messages; if successful, dynamicallydispatched messages can be replaced with direct procedure calls and po ..."
Abstract - Cited by 379 (18 self) - Add to MetaCart
Abstract. Optimizing compilers for object-oriented languages apply static class analysis and other techniques to try to deduce precise information about the possible classes of the receivers of messages; if successful, dynamicallydispatched messages can be replaced with direct procedure calls and potentially further optimized through inline-expansion. By examining the complete inheritance graph of a program, which we call class hierarchy analysis, the compiler can improve the quality of static class information and thereby improve run-time performance. In this paper we present class hierarchy analysis and describe techniques for implementing this analysis effectively in both statically- and dynamically-typed languages and also in the presence of multi-methods. We also discuss how class hierarchy analysis can be supported in an interactive programming environment and, to some extent, in the presence of separate compilation. Finally, we assess the bottom-line performance improvement due to class hierarchy analysis alone and in combination with two other “competing ” optimizations, profileguided receiver class prediction and method specialization. 1

An Architecture-Based Approach to SelfAdaptive Software

by Peyman Oreizy, Michael M. Gorlick, Richard N. Taylor, Dennis Heimbigner, Gregory Johnson, Nenad Medvidovic, Alex Quilici, David S. Rosenblum, Er L. Wolf - IEEE Intelligent Systems 14(3):54 - 62 , 1999
"... A fleet of unmanned air vehicles undertakes a mission to disable an enemy airfield. Pre-mission intelligence indicates that the airfield is not defended, and mission planning proceeds accordingly. While the UAVs are en route to the target, new intelligence indicates that a mobile surface-to-air miss ..."
Abstract - Cited by 299 (19 self) - Add to MetaCart
A fleet of unmanned air vehicles undertakes a mission to disable an enemy airfield. Pre-mission intelligence indicates that the airfield is not defended, and mission planning proceeds accordingly. While the UAVs are en route to the target, new intelligence indicates that a mobile surface-to-air missile launcher now guards the airfield. The UAVs autonomously replan their mission, dividing into two groups—a SAM-suppression unit and an airfield-suppression unit—and proceed to accomplish their objectives. During the flight, specialized algorithms for detecting and recognizing SAM launchers automatically upload and are integrated into the SAM-suppression unit’s software. In this scenario, new software components are dynamically inserted into fielded, heterogeneous systems without requiring system restart, or indeed, any downtime. Mission replanning relies on analyses that include feedback from current performance. Furthermore, such replanning can take place autonomously, can involve multiple, distributed, cooperating planners, and where major changes are demanded and require human approval or guidance, can cooperate with mission analysts. Throughout, system integrity requires the assurance of consistency, correctness, and coordination of changes. Other applications for fleets of UAVs

Back to the future: The story of Squeak, A practical Smalltalk written in itself

by Dan Ingalls, Dan Ingalls, Ted Kaehler, Ted Kaehler, John Maloney, John Maloney, Scott Wallace, Scott Wallace, Alan Kay, Walt Disney Imagineering - In Proceedings OOPSLA ’97, ACM SIGPLAN Notices , 1997
"... Squeak is an open, highly-portable Smalltalk implementation whose virtual machine is written entirely in Smalltalk, making it easy to debug, analyze, and change. To achieve practical performance, a translator produces an equivalent C program whose performance is comparable to commercial Smalltalks. ..."
Abstract - Cited by 209 (4 self) - Add to MetaCart
Squeak is an open, highly-portable Smalltalk implementation whose virtual machine is written entirely in Smalltalk, making it easy to debug, analyze, and change. To achieve practical performance, a translator produces an equivalent C program whose performance is comparable to commercial Smalltalks. Other noteworthy aspects of Squeak include: a compact object format that typically requires only a single word of overhead per object; a simple yet efficient incremental garbage collector for 32-bit direct pointers; efficient bulkmutation of objects; extensions of BitBlt to handle color of any depth and anti-aliased image rotation and scaling; and real-time sound and music synthesis written entirely in Smalltalk. Overview Squeak is a modern implementation of Smalltalk-80 that is available for free via the Internet, at
(Show Context)

Citation Context

..."JIT") virtual machines [Deut84]. Dynamic translation avoids the overhead of byte code dispatch by translating methods into native instructions kept in a size-bounded cache. The Self project [ChUn91] =-=[Hölz94]-=- broke new ground in high performance by investing more compilation time in heavily used methods, using inlining to eliminate expensive calls and enable further optimizations. This work, which was lat...

Adaptive Optimization in the Jalapeno JVM

by Matthew Arnold, Stephen Fink, David Grove, Michael Hind, Peter F. Sweeney - In ACM SIGPLAN Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA , 2000
"... (*58()9$"2#$:0/,;58(03<10/2,>=?33@">"29 #A:0*/,B58(*C2"258/052,D3*>#$,,6-*0'/ 58@F,058*,+HG?!"*0"I"252J58K0/ ,6-*0'/ 030"6N*IO40"58DP)"58QF,058SRUT6252,D<0!2T6252,V52!8("9 "W5X3,06*9E,'Y58(*03C:0'/ X3,06 ..."
Abstract - Cited by 181 (14 self) - Add to MetaCart
(*58()9$&quot;2#$:0/,;58(03&lt;10/2,&gt;=?33@&quot;&gt;&quot;29 #A:0*/,B58(*C2&quot;258/052,D3*&gt;#$,,6-*0&apos;/ 58@F,058*,+HG?!&quot;*0&quot;I&quot;252J58K0/ ,6-*0&apos;/ 030&quot;6N*IO40&quot;58DP)&quot;58QF,058SRUT6252,D&lt;0!2T6252,V52!8(&quot;9 &quot;W5X3,06*9E,&apos;Y58(*03C:0&apos;/ X3,06*9E,&apos;Y58(*03C 1622 *&apos;\,20/2XD3Q#$,U-0/269EU,/52,X&quot;58QF,0&apos;58,+ I,2/2-K58X^528-3L2T6252,_0/252/,58(&apos;4-*0&apos;2,Y 0C#$,058Z#&gt;58,0@=`58a02T/2*(*C/,&apos;:b(/,058c+ \&quot;,25C0d@&quot;3,152058[#;58!*03e0/252,/58( 5805f8(&quot;&quot;52&lt;00&quot;58&gt;b(3589$3,3*&quot;*58QF058C-02,;&quot;(3T Y2520&apos;58258/,03@20&apos;Q&quot;3+ ] D,Q&quot;...

Optimizing Dynamically-Dispatched Calls with Run-Time Type Feedback

by Urs Hölzle, David Ungar , 1994
"... Object-oriented programs are difficult to optimize because they execute many dynamically-dispatched calls. These calls cannot easily be eliminated because the compiler does not know which callee will be invoked at runtime. We have developed a simple technique that feeds back type information from t ..."
Abstract - Cited by 159 (8 self) - Add to MetaCart
Object-oriented programs are difficult to optimize because they execute many dynamically-dispatched calls. These calls cannot easily be eliminated because the compiler does not know which callee will be invoked at runtime. We have developed a simple technique that feeds back type information from the runtime system to the compiler. With this type feedback, the compiler can inline any dynamically-dispatched call. Our compiler drastically reduces the call frequency of a suite of large SELF applications (by a factor of 3.6) and improves performance by a factor of 1.7. We believe that type feedback could significantly reduce call frequencies and improve performance for most other object-oriented languages (statically-typed or not) as well as for languages with type-dependent operations such as generic arithmetic.

Simple and Effective Link-Time Optimization of Modula-3 Programs

by Mary F. Fernández , 1994
"... ..."
Abstract - Cited by 81 (3 self) - Add to MetaCart
Abstract not found
(Show Context)

Citation Context

...33 gcc 51.4 992 m3fe 185 1366 Table 4: Link time in seconds and text size in KB slower to 15% faster. Comparable variations in elapsed times due to code and data placement have been measured for Self =-=[15]-=- when executing on a SPARCstation-2 with a unified, direct-mapped cache. Traditional linkers emit procedures in the order that they occur in modules; we rediscovered the effects of procedure placement...

A brief history of just-in-time

by John Aycock - ACM Computing Surveys
"... Software systems have been using “just-in-time ” compilation (JIT) techniques since the 1960s. Broadly, JIT compilation includes any translation performed dynamically, after a program has started execution. We examine the motivation behind JIT compilation and constraints imposed on JIT compilation s ..."
Abstract - Cited by 79 (2 self) - Add to MetaCart
Software systems have been using “just-in-time ” compilation (JIT) techniques since the 1960s. Broadly, JIT compilation includes any translation performed dynamically, after a program has started execution. We examine the motivation behind JIT compilation and constraints imposed on JIT compilation systems, and present a classification scheme for such systems. This classification emerges as we survey forty years of JIT work, from

Inlining of Virtual Methods

by David Detlefs, Ole Agesen - In 13th European Conference on Object-Oriented Programming
"... We discuss aspects of inlining of virtual method invocations. First, we introduce a new method test to guard inlinings of such invocations, with a different set of tradeoffs from the class-equality tests proposed previously in the literature. Second, we consider the problem of inlining virtual metho ..."
Abstract - Cited by 76 (2 self) - Add to MetaCart
We discuss aspects of inlining of virtual method invocations. First, we introduce a new method test to guard inlinings of such invocations, with a different set of tradeoffs from the class-equality tests proposed previously in the literature. Second, we consider the problem of inlining virtual methods directly, with no guarding test, in dynamic languages such as Self or the Java(tm) programming language, whose semantics prohibit a static identification of the complete set of modules that comprise a program. In non-dynamic languages, a whole-program analysis might prove the correctness of a direct virtual inlining. In dynamic languages, however, such analyses can be invalidated by later class loading, and must therefore be treated as assumptions whose later violation must cause recompilation. In the past, such systems have required an on-stack replacement mechanism to update currently-executing invocations of methods containing invalidated inlinings. This paper presents analyses that allow some virtual calls to be inlined directly even if class loading invalidates the inlining for future invocations. This provides the benefits of direct inlining without the need for on-stack replacement, which can be complicated and require space-consuming data structures.
(Show Context)

Citation Context

...ass, and create and return an instance. Such a class may of course override m2, invalidating the inlining of m2. In the Self system, which did much pioneering work in the field of dynamic compilation =-=[16]-=-, this complication is dealt with by a mechanism called on-stack replacement [18]. In Self, there are deoptimization points within each method, at which the source state of the method, the state of th...

Reconciling responsiveness with performance in pure object-oriented languages

by Urs Hölzle, David Ungar - ACM TRANSACTIONS ON PROGRAMMING LANGUAGES AND SYSTEMS , 1996
"... Dynamically-dispatched calls often limit the performance of object-oriented programs since object-oriented programming encourages factoring code into small, reusable units, thereby increasing the frequency of these expensive operations. Frequent calls not only slow down execution with the dispatch o ..."
Abstract - Cited by 67 (0 self) - Add to MetaCart
Dynamically-dispatched calls often limit the performance of object-oriented programs since object-oriented programming encourages factoring code into small, reusable units, thereby increasing the frequency of these expensive operations. Frequent calls not only slow down execution with the dispatch overhead per se, but more importantly they hinder optimization by limiting the range and effectiveness of standard global optimizations. In particular, dynamicallydispatched calls prevent standard interprocedural optimizations that depend on the availability of a static call graph. The SELF implementation described here offers two novel approaches to optimization. Type feedback speculatively inlines dynamically-dispatched calls based on profile information that predicts likely receiver classes. Adaptive optimization reconciles optimizing compilation with interactive performance by incrementally optimizing only the frequently-executed parts of a program. When combined, these two techniques result in a system that can execute programs significantly faster than previous systems while retaining much of the interactiveness of an interpreted system.

Programming as an Experience: The Inspiration for Self

by Randall B. Smith, David Ungar , 1995
"... The Self system attempts to integrate intellectual and non-intellectual aspects of programming to create an overall experience. The language semantics, user interface, and implementation each help create this integrated experience. The language semantics embed the programmer in a uniform world of si ..."
Abstract - Cited by 61 (0 self) - Add to MetaCart
The Self system attempts to integrate intellectual and non-intellectual aspects of programming to create an overall experience. The language semantics, user interface, and implementation each help create this integrated experience. The language semantics embed the programmer in a uniform world of simple objects that can be modified without appealing to definitions of abstractions. In a similar way, the graphical interface puts the user into a uniform world of tangible objects that can be directly manipulated and changed without switching modes. The implementation strives to support the world-of-objects illusion by minimizing perceptible pauses and by providing true source-level semantics without sacrificing performance. As a side benefit, it encourages factoring. Although we see areas that fall short of the vision, on the whole, the language, interface, and implementation conspire so that the Self programmer lives and acts in a consistent and malleable world of objects.
(Show Context)

Citation Context

...d ones, with no interference from the implementation. 4.1 Transparent Efficiency The implementation techniques for Self have been presented previously so we will only summarize the briefly here. (See =-=[Hol94]-=-, [HU94a], [HCU92], [HCU91], [Cha92], [CU91], [CU90], [CUL89], and [USCH92] for more details.) Self presented large efficiency challenge because its pure semantics implied that every access, assignmen...

Powered by: Apache Solr
  • About CiteSeerX
  • Submit and Index Documents
  • Privacy Policy
  • Help
  • Data
  • Source
  • Contact Us

Developed at and hosted by The College of Information Sciences and Technology

© 2007-2019 The Pennsylvania State University