Ruby Colored Glasses

Last week, my colleagues and I, along with our advisor, headed down to SC08 the 20th anniversary of the annual SuperComputing conference. The conference is huge (they claim 10,000 people attended) and covers everything from new parallel programming paradigms to new high performance computing architectures to new techniques for scientific computing, and there are exhibitors there from traditional vendors like Sun, SGI, and Microsoft, to universities like Indiana University, to national labs like Oak Ridge and Los Alamos. There is so much to do there, it is hard to decide which talks to attend, when to skip out and visit the exhibits, or when to go to the other various interesting talks, workshops what have you. All of that said, I wanted to highlight a couple of things I found particularly interesting.

PGAS

Partitioned Global Address Space (PGAS) programming is a different programming paradigm that sort of spans the difference between shared memory programming (like Pthreads/OpenMP) and message passing programming (like MPI). It instead allows you to treat memory as if it was shared (like shared memory), but gives you control over the “affinity” of that memory for a given process. This means you are aware of what process a block of memory likely lives in, and have the ability to move it locally, perform operations on it in parallel, and in some of the PGAS languages operate with processes as “teams” on the data.

All of this is pretty cool, but two things really stuck out. The first, is that the most mature of the PGAS languages Unified Parallel C (UPC) is implemented as a handful of extensions on top of ISO C99, and hence it might be possible to roll a version of Ruby that could take advantage of concepts from PGAS by compiling Ruby using UPC, and writing a UPC extension to all for experimenting with Ruby PGAS.

The other thing I thought was really interesting about the PGAS languages, are that two of the languages (X10 from IBM and Chapel from Cray) are targeted at high productivity and both provide some concept of object-oriented programming along with closures, making them a great deal more flexible then the traditional Fortran or C/C++ with MPI.

This week is a short week, since we’ve got off for Thanksgiving the last half of the week, and I’m heading home to Connecticut to visit the folks. That said, I still hope to make some progress this week on the partial evaluator, since the poster deadline for eScience 2008, is drawing nigh.

Partial Evaluator

My number one priority this week is getting the basics of the safety checking working for methods, and finishing the parts of the partial evaluator that will let me walk a full Ruby AST. The list of the work to be done, more or less in order, though some of the more advanced handling may be done after a first pass of the partial evaluator is finished for simpler cases.

• Safety check
  • Safety checking of initialize methods for newly created objects
  • Safety checking of non-initialize methods for existing objects and their parameters
  • “Kill list” for variables that have not yet gone out of scope in the Ruby session, but can no longer be used because they may have been changed by an unsafe expression
  • Finish tree-walking for other node types, including handling of branching and looping
  • Special handling for non-new initializers
  • Special handling for require and load and code that calls it
• Simple partial evaluator
  • Evaluate safe statements once (and only once)
  • Output evaluated versions of anything that results in a literal
  • Dead code elimination step, after partial evaluation

While I probably will not be able to get all of this done, I’d at least like to get the basic safety parts working for full Ruby ASTs under the assumption that require and load will not be called.

Slow progress this week. I can’t really point to anything inparticular, but I just had trouble getting focused and getting things done this week. Not having my MacBook Pro, also put me a bit off beat as I’m just so used to it as my development environment.

Fellowship Applications

I did finish up my fellowship applications, with the exception of getting information to my reviewers which I should get done tonight.

Ruby Partial Evaluator

I haven’t really made much progress on this, though I did get a chance to start working on this again a little today. In reflecting on it a little bit, I had mentioned treating calls to new special in two ways:

1. We need to check the initialize function for the implementation, rather then new
2. We can allow code in initialize (or functions it calls) to set instance variables on the newly created object

The second condition here though, I think could be broader. Since any method call can potentially add a new instance variable, I think it may be helpful to maintain a hash of the defined instance variables for a given instance of a class, and always allow the first assign to go without counting it as a modification (since it is really just an extension of the object, rather then a modification of its state). I think this will give us more precise information, though it may make it a little more difficult to be precise about this, since it is not uncommon to have initializer methods other then new or methods that add new instance variables the first time they’re called.

Ruby partial evaluation is the focus this week, with just a little bit of work to finish up for fellowship applications before I get started on this.

Fellowship Applications

• Send references requests off, with a packet of the information I had sent off to NSF
• NPSC Fellowship Application
  • Finish up these essays, largely rewriting and polishing at this point
  • Complete their online forms
  • Put together an equivalent packet for my reference writers for this stuff as well

Ruby Partial Evaluation

• Finish code that extracts properties of a method call (specifically constant, global, class, and instance variables modified or referenced, methods called, and which methods are called on objects passed in as arguments)
• Use properties of method call for special casing new method call (i.e. have it look at initialize
• Begin working on algorithm for determining which side-effects we can partial evaluate, and which will need to wait for runtime.
• Create simple partial evaluator that uses the safety information from the offline analysis to create the partially evaluated code.

Sad Mac News

Also, in sad mac news, my MacBook Pro started to randomly kernel panic on me over the weekend and by Sunday afternoon, was pretty consistent at dieing after 10-15 minutes of up time (at this point it is even less!) So I’m a little off schedule from this weekend. On the plus side, I didn’t loose anything, as I’ve pulled stuff I’ve been working on recently onto my home Linux server, and I’ve got AppleCare on the laptop, so hopefully they’ll be able to fix me up. Still, sad not to have a working laptop!

It was a busy week, this week, but I managed to make progress on both fellowship and Ruby partial evaluation implementation

Fellowships

It was a little down to the wire, but I managed to get my NSF Graduate Student Fellowship application in. The NPSC folks, extended the deadline by a week, so I’ll be finishing that up over the weekend.

Ruby Partial Evaluation

I’ve started working again on the Ruby partial evaluator, specifically focusing on the safety analysis piece of this code. I’ve gotten back to roughly the point where I was before, starting to look at extracting the properties of a function call at a given call site in order to figure out if it is safe or not.

For the first half of this week, I’ll be primarily focused on finishing a couple of fellowship applications that are both due this Wednesday, after that I’ll be getting back to work on the partial evaluator, with our revised algorithm

Fellowship Applications

• Write application essays
• Finish filling out application sheets (by Wednesday)

Partial Evaluator

• Start work on iterative analysis to determine which expressions are safe to evaluate and which are not
  • Initial pass: data-flow analysis to setup known variables/objects and initial method call safety list
  • Iterative pass: using discovered data, extend safety to new expressions, and re-evaluate

At a guess it will be at least next week before I get a chance to begin implementing the partial evaluator that uses this data, even if the safety analysis tool goes fairly smoothly, but once the safety stuff is working, it should make the partial evaluation run relatively quickly.