C. Chambers, D. Ungar, and E. Lee. An e#cient implementation of Self, a dynamically-typed object-oriented language based on prototypes. In OOPSLA, pages 49--70, Oct. 1989.  Home/Search   Document Not in Database   Summary   Related Articles   Check

....features can be implemented e#ciently without extensions to the JVM using dynamic code generation. Of course, dynamic code generation and dynamic compilation techniques have been used widely over the last decade in the implementation of object oriented programming languages (see, for example, [2]) and dynamic and adaptive native code generation in Java runtimes themselves is an example of this. The main contribution of this paper is to show how dynamic and adaptive code generation can also be used by Java programs themselves at the level of Java bytecodes to implement high level dynamic ....

Craig Chambers, David Ungar, and Elgin Lee. An E#cient Implementation of SELF, a DynamicallyTyped Object-Oriented Language Based on Prototypes. In Proceedings of OOPSLA'89, pages 49--70, 1989. Published in SIGPLAN Notices 24(10).

....Thus, even in dynamically compiled systems customization and efficient memory usage need not be mutually exclusive. 1. Introduction Pure object oriented languages such as Self [US87] or Smalltalk [GR83] are difficult to implement because of the high frequency of virtual method calls [DS84] [CUL89]. Much previous work has attempted to overcome this performance problem with a suite of optimization techniques aimed at reducing the cost of dynamic dispatch: inlining [CU93] customization ( CU89] CU93] splitting ( CU93] CU90] type inference [APS93] type feedback [HU94a] specialization ....

....by message sends. To overcome the performance problems posed by frequent dynamically dispatched calls, Self 93 uses customization and other optimizations to eliminate most of the runtime message sends. Customization allows the compiler to determine the types of many message receivers in a method [CUL89]. It extends dynamic compilation by exploiting the fact that many messages within a method are sent to self, the receiver of the current method. The compiler creates a separate compiled version of a given source method for each receiver type (Figure 1) For example, it might create two separate ....

Craig Chambers, David Ungar, and Elgin Lee. An Efficient Implementation of SELF, a Dynamically-Typed Object-Oriented Language Based on Prototypes. In OOPSLA `89 Conference Proceedings, p. 49-70, New Orleans, LA, October

....and post call operations around each method invocation, for example to produce traces of application behaviour, to introduce locking around invocations or to perform access control checks. 14 SELF 2.1. 4 Unlike Smalltalk, self is a pure prototype based object oriented programming language [Chambers89] This means that it uses an existing object, rather than a class definition, as the blueprint when making an instantiation. For example the new object may obtain methods, fields and field values from the prototype object. A class based style of programming is possible by creating separate ....

Craig Chambers, David Ungar, and Elgin Lee. An efficient implementation of SELF, a dynamically-typed object-oriented language based on prototypes. In Object-Oriented Programming, Systems, Languages & Applications (OOPSLA '89), volume 24(10) of ACM SIGPLAN Notices, pages 49--70, October 1989. (p 15)

....and a five bit index , or instruction argument. The eight instructions are: push self, push literal, send message (to invoke a method or access a field) self send, super send, delegate (to a parent) return, and index extension. The bytecode is dynamically translated into efficient machine code [28,29]. Java (1994) is a statically typed class based object oriented language, whose official intermediate language is the statically typed Java Virtual Machine (JVM) bytecode. The JVM has special support for dynamic loading and linking, with load time verification (including type checking) of ....

C. Chambers, D. Ungar, E. Lee, An efficient implementation of Self, a dynamically typed object-oriented language based on prototypes, Lisp Symbol. Comput. 4 (3) (1991) 57--95.

....and a five bit index , or instruction argument. The eight instructions are: push self, push literal, send message (to invoke a method or access a field) self send, super send, delegate (to a parent) return, and index extension. The bytecode is dynamically translated into efficient machine code [28,29]. Java (1994) is a statically typed class based object oriented language, whose official intermediate language is the statically typed Java Virtual Machine (JVM) bytecode. The JVM has special support for dynamic loading and linking, with load time verification (including type checking) of ....

C. Chambers, D. Ungar, E. Lee, An efficient implementation of Self, a dynamically typed object-oriented language based on prototypes, in: OOPSLA'89, New Orleans, LA, October

....to postpone some code generation until even later than suggested by Figure 6, so that specialized versions of some parts of the program could be generated dynamically at run time. Similar techniques have been used with considerable success in the implementation of the object oriented language Self [3]. Source modules Compiler Intermediate code High level linker Specialization Specialized program Code generation Object code Low level linker Executable program Figure 6: Separate compilation with specialization We should also point out that, despite the ....

C. Chambers, D. Ungar and E. Lee. An efficient implementation of Self, a dynamically-typed object-oriented language based on prototypes. Lisp and symbolic computation, 4, 3, 1991.

....specifications and makes it easy, for instance, to find out which behavior is fixed and which behavior is variable. Obviously, the fixed behavior can then be optimized easily, e.g. through inlining. For the variable behavior, dynamic optimization techniques e.g. as adopted by SELF [Hlzle 94] Chambers 89] are required. 5.2 Related work We mention the encapsulators framework [Pascoe 86] as a Smalltalk based representative of related work. This framework offers an approach that is similar to the ideas motivating the composition filters model: an application object can be surrounded with a layer ....

C. Chambers, D. Ungar & E. Lee, An Efficient Implementation of SELF, a Dynamically-Typed Object -Oriented Language Based on Prototypes. Proc. of the OOPSLA `89 Conference, ACM SIGPLAN Notices, 24(10), October 1989, pp. 49-70.

....that the called method is declared inline; some C compilers only inline functions explicitly declared inline. Second, the inline function may be specialized since its receiver type is precisely known to be a B (and only a B) Thus, implicit self calls within the method can be statically bound [CUL89]. 4.6 Inlining Strategies Some calls should not be inlined; for example, if a call has 20 different receiver types, each of which occurs 5 of the time, inlining is unlikely to improve performance: inlining just one case improves only 5 of the call site s executions but slows down the 11 other ....

Craig Chambers, David Ungar, and Elgin Lee. An Efficient Implementation of SELF, a Dynamically-Typed Object-Oriented Language Based on Prototypes. In OOPSLA `89, Object-Oriented Programming Systems, Languages and Applications, p. 49-70, New Orleans, LA, October 1989. Published as SIGPLAN Notices 24(10), October 1989.

....speedup that can possibly be achieved by using it. A variety of techniques have been proposed to speed up execution (and message dispatch in particular) of systems based on the pure object oriented languages Smalltalk and Self. The resulting dynamic compilation systems [Ungar and Smith 1987; Chambers et al. 1989; Holzle et al. 1991; Chambers 1992; Holzle 1994; Holzle and Ungar 1996] provide incremental code generation, but once a piece of code has been optimized, it becomes static. Hence, no re optimization is performed in response to changes in user behavior. One of the central findings of this paper, ....

Chambers, C., Ungar, D., and Lee, E. 1989. An E#cient Implementation of SELF, a Dynamically-Typed Object-Oriented Language Based on Prototypes. In Proceedings of the Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA) , Volume 24, New York, NY, pp. 49--70. ACM Press.

....programs: caching will speed up programs if the cached information is used often before it is evicted from the cache. This section discusses two kinds of caching: global caching (one large cache per system) and inline caching (one one entry cache per call site) 1 This is done in SELF [16]. Indirect instance variable access is used in Eiffel and Sather [102] Figure 8. Memory layout of objects in the case of multiple inheritance. pa a1 A B C . pb b1 . pc a1 . c1 . b1 . adjusted pb A C B The offset of instance variable b1 is different in instances of B versus ....

....is, we cannot hope for much more than a performance improvement of around 5 10 for the C measured here. Java programs, where all member functions are declared virtual, can gain between 5 and 50 . Any further improvement must come from other optimizations such as customization or inlining [16][70] Given that better optimizing compilers are possible [6] it hardly seems appropriate for programmers to compromise the structure of their programs to avoid dispatch. Many object oriented systems use or could use VFT like dispatch mechanisms (e.g. implementations of Java, Modula 3, Oberon 2, ....

[Article contains additional citation context not shown here]

Craig Chambers, David Ungar, and Elgin Lee. An Efficient Implementation of SELF, a Dynamically-Typed Object-Oriented Language Based on Prototypes. In OOPSLA `89 Conference Proceedings, p. 49-70, New Orleans, LA, October 1989. Published as SIGPLAN Notices 24(10), October 1989. 166

....subclasses to discard procedures of the superclass, so in this case the stack class could inherit from the deque class. Although most of the widely used object oriented languages are class based, classes are not an essential aspect of object orientation. Delegation languages such as SELF [US87] CUL89] achieve reusability by allowing each object to delegate some of its procedures to another object [Lie86] This is similar to inheritance, but occurs between objects rather than between classes. It is particularly useful when an object needs to able to change its behaviour radically [JZ91] this ....

Craig Chambers, David Ungar, and Elgin Lee. An efficient implementation of SELF, a dynamically-typed object-oriented language based on prototypes. SIGPLAN Notices, 24(10), October 1989. Proceedings of OOPSLA '89. Ref. on page 23.

....compiler. Smalltalk methods (procedures) tend to be very small, making aggressive inline substitution necessary to achieve good performance. Type information is required to bind methods at compile time. Although some type information can be acquired by dataflow analysis of individual methods [CUL89], explicit type declarations produce better results and also make programs more reliable and easier to understand. From this point of view, the type system has been quite successful, because the TS compiler can make Smalltalk programs run nearly as fast as C programs. It is important that a type ....

Craig Chambers, David Ungar, and Elgin Lee. An efficient implementation of Self, a dynamically-typed object-oriented language based on prototypes. In Proceedings of OOPSLA `89, pages 49--70, October 1989. printed as SIGPLAN Notices, 24(10).

....it from Smalltalk, the more general conclusions made in Chapter 3 can be applied to their system. Hense [Hen90, Hen91] has looked at the problem of incremental type inference and so has developed a way of defining extensible types to aid typing in the presence of code re use. SELF [US87, CU89, CUL89, CU91] the language introduced in the first chapter, has had several generations of compilers developed for it over a period of time, each adopting various CHAPTER 2. WHY ANALYSE PROGRAMS 22 optimisation techniques, for example, compiling specialised versions where possible or practical, and ....

Craig Chambers, David Ungar, and Elgin Lee. An efficient implementation of SELF, a dynamically-typed object-oriented language based on prototypes. ACM SIGPLAN Notices, 24(10):49--70, October 1989. Proceedings of the Conference on Object-Oriented Programming: Systems, Languages and Applications.

....all data structures at compile or link time and do not change those data structures at run time. Thus, static techniques only use information that can be statically derived from the program s source text. Dynamic techniques may 1 Alternatively, a system could duplicate code (e.g. as in Self [CUL89]) or access instance variables indirectly (as is done in Eiffel and Sather [MS94] a 0 A c 1 B e 4 C f 2 a 3 f 5 g 6 D b 7 d 8 E A a B acf C e E bd D fg Figure 2. Class hierarchy with corresponding dispatch tables 4 Message dispatch on modern computer architectures ....

.... of single dispatch, but such implementations may not be optimal [AGS94] Dispatch overhead can also be reduced by eliminating dispatches (rather than just making them fast) For example, the Self 93 system eliminates 95 of all dispatches [Hl94] with compiler optimizations such as customization [CUL89] and type feedback [HU94] Similarly, concrete type inference [OPS92] VHU92] APS93] PC94] can determine the concrete receiver types of calls, possibly eliminating dynamic dispatch for many sends. The Apple Object Pascal linker [App88] turned dynamically dispatched calls into statically bound ....

Craig Chambers, David Ungar, and Elgin Lee. An Efficient Implementation of SELF, a Dynamically-Typed ObjectOriented Language Based on Prototypes. In OOPSLA `89 Conference Proceedings, p. 49-70, New Orleans, LA, October 1989. Published as SIGPLAN Notices 24(10), October 1989.

....whereas type inference would give its type as Integer, BigInteger . Thus, the type inferencer benefits from the same local analysis that the standard system uses, so that the two can be fairly compared. The current SELF implementation requires that all methods be customized to their receiver [CUL89], and thus methods will be customized to a specific receiver even if the type inferencer does not require it. Similarly, the runtime system does not support multiple dispatch, so that the compiler may have to merge some method templates that differ only in their argument types. To evaluate type ....

....type feedback requires a dispatch test even if it predicts a i.e. sends that do not require any dispatch. Examples include sends where type inference determined a single receiver class (but did not inline the send) or implicit self sends (which require no dispatch because of customization [CUL89]) # For example, the system using type feedback compiles methods in different order (since it adaptively optimizes the program [Hl94] and thus generates a different set of methods. Figure 5. Number of non inlined message sends relative to unoptimized SELF Tiny (median) Small (median) ....

[Article contains additional citation context not shown here]

Craig Chambers, David Ungar, and Elgin Lee. An Efficient Implementation of SELF, a DynamicallyTyped Object-Oriented Language Based on Prototypes. In OOPSLA `89 Conference Proceedings, p. 4970, New Orleans, LA, October 1989. Published as SIGPLAN Notices 24(10), October 1989.

....targeted at reducing the cost of dynamic dispatch in order to improve performance. So far, much of the research on such optimizations has concentrated on pure object oriented languages because the frequency of dynamic dispatch is especially high in such languages. Several studies (e.g. [CUL89], HU94a] G 95] have demonstrated that optimization can greatly reduce the frequency of dynamic dispatch in pure object oriented languages and significantly improve performance. However, so far no study has shown that these optimizations also apply to a hybrid language like C where the ....

Craig Chambers, David Ungar, and Elgin Lee. An Efficient Implementation of SELF, a DynamicallyTyped Object-Oriented Language Based on Prototypes. In OOPSLA `89, Object-Oriented Programming Systems, Languages and Applications, p. 49-70, New Orleans, LA, October 1989. Published as SIGPLAN Notices 24(10), October 1989.

....Les slots de donn ees se subdivisent en deux cat egories: ceux qui sont mutables et ceux qui sont immuables. Les slots fonctionnels sont consid er es en principe comme immuables. Slots de donn ees La distinction entre slots de donn ees mutables et immuables est faite syntaxiquement, a la Self [CUL89], lors de la d eclaration du slot: nom = valeur ) d efinit un slot comme slot de donn ee immuable. La valeur, qui lui est assign ee a sa cr eation, n est plus modifiable par la suite. Le slot ainsi g en er e ne permet que d acc eder en lecture a la donn ee. nom valeur ) d efinit un ....

....est absent. Cette impl ementation de la d el egation ne g ere pas les appels aux m ethodes masqu ees, tels qu ils sont trait es par le super de Smalltalk, ou le (call next method) de CLOS. Nous pourrions n eanmoins enrichir notre mod ele en utilisant une construction proche du resend de Self [CUL89]. 4.3 Reconception des objets points Nous pouvons utiliser ce mod ele de d el egation pour impl ementer les points (x,y) d une mani ere nouvelle, plus proche de l organisation des prototypes pron ee par Self. Ainsi en Self, il est d usage de factoriser les comportements communs a une famille ....

Craig Chambers, David Ungar and Elgin Lee. An Efficient Implementation of SELF, a Dynamically-typed Object-Oriented Language Based on Prototypes. In Proceedings of OOPSLA'89, ACM Sigplan Notices, 24(10):49-70.

....feature that supports abstraction is the dynamic dispatch of methods based on the run time type of an object. In dynamically typed languages like Smalltalk and SELF, all dispatches are considered dynamic, and eliminating these dynamic dispatches has been essential to obtaining high performance [9, 14, 24]. C is a more conservatively designed language. Programmers must explicitly request dynamic dispatch by declaring a method to be virtual. C programs therefore suffer less of an initial performance penalty, at the cost of reduced flexibility and increased programAppears in the Proceedings of ....

Chambers, C., Ungar, D., and Lee, E. An efficient implementation of SELF, a dynamicallytyped object-oriented language based on prototypes. LISP and Symbolic Computation 4, 3 (July 1991), 243--281.

....of the Self 1.0 prototype based language [MR91] that we then extended to perform reflective computation [CMDM92] Our purpose was also to add reflective facilities to control the computation rules of message sending. In standard Self, prototype structure can be consulted thanks to mirror objects [CUL89]. These first class objects are created explicitly to provide an interface between a prototype and its internal representation. Unfortunately, mirrors are not causally connected to the internal structure they only give a reading access to and are mainly used to create virtual slot descriptor ....

....binding. We distinguish two kinds of slots: data slots and function slots. Data slots are themselves divided into two categories: mutable and immutable slots. Function slots are immutable slots. Data Slots The distinction between mutable and immutable slots occurs at declare time, as in Self [CUL89], according to the following syntax: name = value ) declaration of an immutable data slot. The value of the slot is computed at creation time, and cannot be changed afterwards. In fact, the slot produced by such a declaration is only a reading accessor to the data stored. name ....

Craig Chambers, David Ungar and Elgin Lee. An Efficient Implementation of SELF, a Dynamically-typed Object-Oriented Language Based on Prototypes. In Proceedings of OOPSLA'89, ACM Sigplan Notices, 24(10):49-70. 1989.

....benefits from the same local analysis that the standard system uses, so that the two can be fairly compared 2 . Two limitations of the current SELF virtual machine affect the type inference based compiler. First, the virtual machine requires that all methods be customized to their receiver [CUL89]. Consequently, methods will be customized to a specific receiver even if the type inferencer does not require it. Second, the run time system, unlike the type inferencer, does not support multiple dispatch. Therefore, the compiler sometimes must merge templates that differ only in their argument ....

....does not imply call in our terminology; see section 3.5. 3 i.e. sends that do not require any dispatch. Examples include sends where type inference determined a single receiver class (but did not inline the send) or implicit self sends (which require no dispatch because of customization [CUL89]) 4 For example, the system using type feedback compiles methods in different order (since it adaptively optimizes the program [Hl94] and thus generates a different set of methods. Section Data measured Motivation Main result 3.4 non inlined sends message inlining is important for ....

[Article contains additional citation context not shown here]

Craig Chambers, David Ungar, and Elgin Lee. An Efficient Implementation of SELF, a DynamicallyTyped Object-Oriented Language Based on Prototypes. In OOPSLA `89, Object-Oriented Programming Systems, Languages and Applications, p. 49-70, New Orleans, LA, October 1989. Published as SIGPLAN Notices 24(10), October 1989.

.... attempts to add the receiver self to its argument i using the primitive IntAdd:IfFail: The primitive operation succeeds if Java bytecodes Self bytecodes section design goal fast interpretation minimality, compactness number of bytecodes 200 (shown in full in appendix) 7 (described in detail in [2]) primitive types 8, 16, 32, 64 bit integers; 32, 64 bit floats; 16 bit chars 30 bit integers (2 tag bits) 30 bit floats 5.1 operations on primitive types, e.g. integer add each operation has its own bytecode done by calling primitive methods 5.1 expression stack operations ....

Craig Chambers, David Ungar, and Elgin Lee. An Efficient Implementation of SELF, a Dynamically-Typed Object-Oriented Language Based on Prototypes. In Lisp and Symbolic Computation 4(3), Kluwer Academic Publishers, June

....which makes dynamic compilation for the particular filter possible to speed up the packet selection. Yet another benefit of dynamic compilation is that it can be an enabling technology for very high level language features, such as dynamic dispatching of message sends in object oriented languages [CUL89] A key issue for dynamic compilation is how to identify where and when to compile code dynamically. There are different approaches to this problem. In the declarative, annotation based approach, the programmer uses annotations specifying what to compile at runtime, but does not need to write ....

Craig Chambers, Dave Ungar, and E. Lee. An efficient implementation of self, a dynamically-typed object-oriented language based on prototypes. In Sigplan Notices, volume 24, pages 49--70, October 1989.

No context found.

C. Chambers, D. Ungar, and E. Lee. An e#cient implementation of Self, a dynamically-typed object-oriented language based on prototypes. In OOPSLA, pages 49--70, Oct. 1989.

No context found.

Chambers C, Ungar D, Lee E. An efficient implementation of Self, a dynamically-typed object-oriented language based on prototypes. Proceedings of the ACM Conference on Object-Oriented Programming Systems, Languages, and Applications, New Orleans, Louisiana, October 1989. ACM SIGPLAN Notices 1989; 24(10):49--70.

No context found.

Craig Chambers, David Ungar, and Elgin Lee. An Efficient Implementation of Self, a Dynamically-Typed Object-Oriented Language Based on Prototypes. In OOPSLA '89 Proceedings, pp. 49--70. ACM, Oct. 1989.

First 50 documents

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC