[BBLISA-announce] Memory Models for Programming Languages, Dr. Guy L. Steele Jr.

[Adam S. Moskowitz]

The Boston Chapter of the IEEE Computer Society presents:

Harvard University Computer Science Colloquium Series

Date/Time:  March 25, 2004, 4 PM - 5 PM

Location:   Harvard University, Maxwell Dworking, Room G125,
            (Ice Cream at 3:30PM - Maxwell Dworkin 2nd Floor Lounge Area)

Title:      Memory Models for Programming Languages

Speaker:    Dr. Guy L. Steele Jr., Sun Microsystems Laboratories


Abstract:

In a programming language, what does it mean to refer to a variable?

For a conventional sequential program, the meaning is relatively
simple. Computer systems architects have designed elaborate hardware
structures, such as registers, caches, and out-of-order instruction
execution, as well as software structures such as optimizing compilers,
that deliver greatly improved performance while maintaining the illusion
that the behavior of memory locations is simple.

But with the advent of parallel processors with multithreaded programming,
the illusion of simplicity has been shattered. If memory is shared, the
elaborate under-the-table cleverness that accelerates one thread may be
observed by other threads, resulting in program behavior that can astonish
the programmer.

It is not adequate for a shared-memory language specification merely
to say, as many do, that a parallel program consists of many sequential
threads, each behaving as specified by the standard specification for a
sequential language. Specifications of sequential languages do not address
questions of memory behavior that arise only in multithreaded contexts. A
very few recent programming language specifications do address the
question of the behavior of memory locations shared by multiple threads,
but the model for Unified Parallel C is incomplete and the model for Java
has turned out to be flawed. Inappropriate memory behavior can result
in violations of a language's type system or in reading values from a
variable that were never written.

The question that we raise (and do not completely answer) in this talk
is: Can we find a model of memory behavior that imposes constraints tight
enough for programs to have "reasonable" behavior while also loose enough
that the by now conventional techniques for acceleration of execution
are not prohibited?


Host: Professor Norman Ramsey