[IP] Bytecode-to-bytecode adaptive optimization for Smalltalk -- talk in Palo Alto (fwd)

Eugen Leitl eugen@leitl.org
Sun, 9 Mar 2003 17:08:42 +0100 (CET)


---------- Forwarded message ----------
Date: Sun, 09 Mar 2003 10:22:18 -0500
From: Dave Farber <dave@farber.net>
To: ip <ip@v2.listbox.com>
Subject: [IP] Bytecode-to-bytecode adaptive optimization for Smalltalk --
    talk in Palo Alto


              COMPUTER SYSTEMS LABORATORY COLLOQUIUM
                4:15PM, Wednesday, March 12, 2003
       NEC Auditorium, Gates Computer Science Building B03
                   http://ee380.stanford.edu[1]
                   
Topic:    Bytecode-to-bytecode adaptive optimization for Smalltalk
          Compilation and execution architecture for late-bound
          object-oriented programming languages

Speaker:  Eliot Miranda
          Cincom Systems, Inc.

About the talk:

This talk summarises two decades of work on Smalltalk and Self
compilation and virtual machine technology and describes a novel
attempt at an adaptive optimizer for Smalltalk that is written in
Smalltalk and to a meaningful extent, portable across
implementations.

Smalltalk-80 and Self are fully object-oriented implicitly typed
dynamic programming languages and interactive programming
environments hosted above virtual machines that appear to execute
stack-oriented bytecode for a pure stack machine. These systems'
code and execution state are all represented by objects
programmed in Smalltalk, such that the compiler, debugger,
exception system and more are all implemented entirely in
Smalltalk and available to the programmer for immediate
incremental and interactive modification.

Such an architecture places great demands on the virtual machine
to provide high performance. These demands have led to a series
of ground breaking virtual machine architectures from the
original microcoded implementations through Deutsch and
Schiffmann's dynamic translation systems, and Ungar, Chambers and
Hoelzle's adaptive optimizers for Self. The key insight that the
polymorphic inline caches used to speed up message sends
(late-bound procedure calls) also provide concrete type
information that can be used to optimize a running program led to
Hoelzle's Self-4 run-time type-feedback adaptive optimizer, the
Animorphic Smalltalk implementation and to Sun's HotSpot server
Java VM.

Up until now these architectures have all been implemented in C
or C++, and have generated machine code, incurring comcomitant
costs in implementation difficulty, portability and
extensibility. But the explicit representation of code and
execution state make it convenient to implement a hybrid
architecture where an adaptive optimizer written entirely in
Smalltalk, guided by type information obtained from the VM,
produces optimized bytecoded methods that are executed by a
more-or-less conventional VM.

While the architecture does not aim to provide the ultimate in
execution performance, it does aim to provide an excellent ratio
of performance to implementation effort, and to provide a means
of unifying the Smalltalk implementation community through an
open source and portable code base.

The talk will present the key technical components of these
architectures and some of the social history behind them.

About the speaker:

Eliot Miranda is a habitual Smalltalk virtual machine
implementor, starting in 1983 in a summer job at the Rutherford
Appleton Laboratory. This obsession took him first to Queen Mary
Westfield College, University of London where his implementations
were used for teaching and research and where he lectured before
joining Harlequin Ltd to work on Dylan in 1993.

Since joining ParcPlace Systems in 1995 he has been working with
VisualWorks, the direct commercial descendent of the original
Xerox Smalltalk-80 system. He became technical lead for
VisualWorks in 1997, essentially because he stayed while wiser
colleagues either left or were let go. ParcPlace merged with
Digitalk in 1995, changed its name to ObjectShare in 1997, and
sold the VisualWorks technology to Cincom Systems in 1999, his
current employer.

Eliot's own BrouHaHa Smalltalk-80 virtual machine implementations
used a number of cheap tricks best summed up as C compiler abuse
to provide "good" performance with little implementation effort.
This economy of means has proved well suited to enhancing
VisualWorks, a once proud implementation fallen on hard times, as
Smalltalk vendors are unwilling or unable to provide the
personnel resources available to competing technologies such as
Java.

Eliot holds a BSc in Computer Science from the University of
York, UK, and is a member of the ACM.

Contact information:

Eliot Miranda
eliot@parcplace.com[2]


Embedded Links:
[ 1 ]    http://ee380.stanford.edu
[ 2 ]    mailto:eliot@parcplace.com


------ End of Forwarded Message

-------------------------------------
You are subscribed as eugen@leitl.org
To manage your subscription, go to
  http://v2.listbox.com/member/?listname=ip

Archives at: http://www.interesting-people.org/archives/interesting-people/