June 14, 2012 - Object Initialization in X10
Speaker: David Cunningham
Venue: ECOOP'12
June 14, 2012 -- X10 Workshop at PLDI/ECOOP
In addition to 6 refereed presentations, Dave Grove will give a mini-tutorial on X10 and its implementation, David Cunningham will give an invited talk on M3R: Increased Performance for In-Memory Hadoop Jobs, and Dave Grove will lead a discussion on future X10 plans.
There will also be a session of "Lightning Talks" that will allow community members a few minutes to share their X10 experiences.
June 11, 2012 - Implementing X10: Spanning High-Performance Computing & Big Data
Speaker: Dave Grove
Venue: ICOOOLPS Workshop (co-located with ECOOP 2012).
May 28, 2012 - Concurrent Objects and Beyond: From Theory to High-Performance Computing
Speaker: Vijay Saraswat
May 30, 2012 - Shonan meeting on Parallel Constraint Solving
Title: SatX10: An architecture for Capability Constraint Solving in X10
Speaker: Vijay Saraswat
June 14, 2012 - Beijing, China, PLDI'12 Workshop
Recent Events
November 14-17, 2011 - Seattle, Washington, Supercomputing'11, Full Day Tutorial
Tutorial Title:Developing Scalable Parallel Applications in X10
Speakers: David Cunningham, David Grove, Vijay Saraswat, Olivier Tardieu
October 22-27, 2011 - Portland, Oregon, SPLASH'11
X10 Birds-of-a-Feather Session
Speakers: David Grove, Vijay Saraswat, David Cunningham
October 22-27, 2011 - Portland, Oregon, SPLASH'11
Demo Title: Distributed Ray Tracing in X10
Speaker: David Cunningham
October 19, 2011 - A 2-hour lecture at the University of Tokyo, Japan
Lecture Title: Parallel Distributed Programming Language X10 (in Japanese)
Speaker: Kiyokuni Kawachiya [Slides (in Japanese)]
September 12, 2011 - Perugia, Italy, PMCS workshop, co-located with CP2011
Talk Title: Writing parallel constraint solvers, simply
Speaker: Vijay Saraswat
September 10, 2011 - Columbus, Ohio, Ohio LinuxFest 2011
Keynote Title: Programming in the Concurrency Era: The X10 programming language
Speaker: Vijay Saraswat
September 8, 2011 - Fort Collins, Colorado, LCPC workshop, Keynote
Keynote Title: Constrained types: What are they and what can they do for you
Speaker: Vijay Saraswat
September 8, 2011 - Fort Collins, Colorado, LCPC workshop, Keynote
Keynote Title: Constrained types: What are they and what can they do for you
Speaker: Vijay Saraswat
Abstract
One of the major innovations of the X10 programming language is constrained types [OOPSLA 2008]. A constrained type is of the form N{c} where N is the name of a class/struct/interface and c is a constraint on the properties (marked immutable instance fields) of N. Constraints may reference any accessible immutable variable and may be drawn from any vocabulary of predicates, as long as an underlying constraint solver is available.
For instance, an object o is of type Matrix{self.I==self.J} if it is of type Matrix and o.I==o.J. The signature of matrix multiply can be given by def mult(a:Matrix{self.I==this.J}):Matrix{self.I==this.I, self.J==a.J}. If the class Tree is augmented with a property root:Tree, then the type Tree{self.root=o} is precisely the type of all nodes in the tree with root o (cf membership in ownership domains).
Constrained types may occur wherever types can occur -- including in declarations of variables, fields and parameters, return types of methods, dynamic casts, annotations etc. The X10 compiler statically checks symbolic entailment of constraints when performing subtype checks (e.g. to determine if an expression can be assigned to a variable, or returned from a method).
Constrained types are a particularly powerful form of dependent types well-suited to object-oriented programming languages. They draw power from the natural impredicativity of object-oriented languages -- the type of any field of a class T can be T or any class which has fields of type T. Indeed, checking entailment of constrained types even with just == and != constraints is undecidable (because of impredicativity).
Constrained types are very valuable in code generation and array bounds checking. For instance, the type Array[T] in X10 can be defined over arbitrarily shaped index regions. The type Rail[T] is defined as Array[T]{self.rank==1,self.zeroBased,self.rect}, i.e. the set of all arrays o of type T such that o's region is 0..N for some N. If the compiler infers that a variable is of type Rail[T] it generates much more efficient code for accessing its elements. Similarly, if x:Array{self.region==r}, and p:Point(r.inner(1)) (where r.inner(k) represents all those points p such that p+k lies in r), then x(p) and x(p+1) can be statically established to be legal accesses (without knowing the value of r) since p and p+1 lie in r. (*)
Constrained types can also be used for safety analysis of concurrent programs, in particular for establishing that two pieces of parallel code affect disjoint partitions of the heap (= zones), and hence can commute with each other. In particular we show how the "region effects" of Deterministic Parallel Java (DPJ) can be naturally represented in X10 using constrained types. For instance the type of all arrays x of type T whose members x(p) lie in the zone Zone(x.zone,p) obtained from x.zone using the index p can be described by x#Array[(p:x.region)=> T{self.zone==Zone(x.zone,p)}]. Using this the compiler can establish that if p!= q and p,q lie in x.region then x(p) != x(q). (*)
(*) These constraints cannot be processed by the X10 2.2 compiler. Work is in progress to add support for such constraints.
The talk is based on joint work with Nate Nystrom, Igor Peshansky, Olivier Tardieu, Dave Grove, Dave Cunningham, Yoav Zibin and Avi Shinnar.
September 10, 2011 - Columbus, Ohio, Ohio LinuxFest 2011
Keynote Title: Programming in the Concurrency Era: The X10 programming language
Speaker: Vijay Saraswat
Abstract:
The concurrency era is here.
Finally.
The only way for software to continue to ride Moore's law is to go parallel and scale out. But how? For most application programmers, the prospect of having to deal with low-level concurrent programming in MPI, OpenMP or CUDA is unappetizing at best.
In 2004 we started the (open-source) X10 programming language project at IBM Research with funding from DARPA to address performance and productivity at scale. X10 is a strongly typed, imperative, object-oriented language in the tradition of Java, with a very few orthogonal constructs for fine-grained concurrency and distribution (places, asychnrony, termination detection, atomicity). X10 offers a single, high-level, programming model subsuming MPI (multi-node execution across a cluster), OpenMP (shared memory concurrency within a node) and CUDA (essentially vectorization within a GPU), while offering rich semantic guarantees.
Programs in a large fragment of the language are guaranteed to be safe, that is, equivalent to the underlying sequential program (hence deadlock-free and determinate).
X10 can be compiled to run on JVMs (inter-operating with Java) or natively, and runs on top of Ethernet or Infiniband, via sockets, MPI and more modern one-sided messaging systems.
The talk presents an overview of the X10 programming language, the underlying APGAS programming model, and its implementation. It shows how various concurrent programming idioms can be naturally expressed within X10, and presents some performance numbers.
Bio: Vijay Saraswat is a Research Staff Member at the IBM TJ Watson Research Center, and manages the Advanced Programming Languages group. Vijay's areas of research are programming languages, concurrency and constraints. After nearly a decade at Xerox PARC working on model-based reasoning, constraint languages and natural language processing, he moved to AT&T Research in the mid 90s to found the Matrix project in social computing. He led the development of the AT&T Instant Messaging system, and co-chaired IETF working groups in presence protocols and instant messaging. After stints at start ups and a year as a Professor at Penn State, Vijay joined TJ Watson in 2003 where he has co-led the X10 project since its inception.
Vijay's 1989 CMU PhD thesis on "Concurrent Constraint Programming" won the ACM Doctoral Dissertation Award, was published by MIT Press, and founded a sub-field of research in declarative, high-level concurrency. A subsequent paper in this area was honored with a "Best in 20 years" award. Vijay has co-authored scores of papers, edited multiple books and lectured all over the world.
September 12, 2011 - Perugia, Italy, PMCS workshop, co-located with CP2011
Title: writing parallel constraint solvers, simply
Speaker: Vijay Saraswat
Abstract
The concurrency era is here.
Finally.
The only way for software to continue to ride Moore's law is to go
parallel and scale out. But how? For the expert in SAT or mixed
integer programming, the prospect of having to deal with low-level
concurrent programming in MPI, OpenMP or CUDA is unappetizing at best.
In 2004 we started the X10 programming language project at IBM
Research with funding from DARPA to address performance and
productivity at scale. X10 is a strongly typed, imperative,
object-oriented language in the tradition of Java, with a very few
orthogonal constructs for fine-grained concurrency and distribution
(places, asychnrony, termination detection, atomicity). X10 offers a
single, high-level, programming model subsuming MPI (multi-node
execution across a cluster), OpenMP (shared memory concurrency within
a node) and CUDA (essentially vectorization within a GPU), while
offering rich semantic guarantees. Programs in a large fragment of the
language are guaranteed to be deadlock-free and determinate.
X10 can be compiled to run on JVMs (inter-operating with Java) or
natively, and runs on top of sockets, MPI and more modern one-sided
messaging systems.
In this talk we show how parallel constraint solvers can be written
simply and elegantly in X10. With a few dozen lines of X10 code it is
possible to run in parallel multiple existing sequential constraint
solvers (written in Java or C/C++, e.g. MiniSat), in such a way that
they can communicate constraints to each other. We discuss the "global
load balancing" framework (written in a few hundred lines of X10) that
permits (relocatable) user tasks to be efficiently load balanced
across a cluster, using a new technique, life-line based
work-stealing. In PPoPP 2011 we presented best known efficiency
numbers for the unbalanced tree search problem using these ideas. We
believe such support makes X10 ideal for experimenting with parallel
portfolio-based solvers in various domains such as SAT or mixed
integer programming.
Work on parallel MiniSat was done with Dave Cunningham, IBM.