You are currently browsing the tag archive for the ‘parallel’ tag.

I’m working at the University of Toronto this summer, on a research project called JSCOOP. We’re bringing the SCOOP concurrency model to Java, by way of an Eclipse plugin and Java 1.5 annotations. It’s really, really cool stuff that started at York University and moved down here. I’m working underĀ Marsha Chechik with Faraz Torshizi.

I’m also continuing the Cowichan parallel survey with Andrew Borzenko, under Greg Wilson. Last term we successfully implemented the problem set using Boost::MPI and Threading Building Blocks (TBB). So that’s two parallel paradigms down, and many, many more to go. This is what we’re up to this term:

  1. Tightening up the serial implementation. There’s a lot to be said for having a strong base to start from, and having the fastest serial implementation we can produce will be important for performance comparison.
  2. Standardizing the header files. As we’re only looking at implementing the problem set in C++ using libraries available to it at the moment, we’re defining a standard interface for the problems so that they can be called/chained in an abstract fashion. This also lets us put the performance evaluation code in one place.
  3. Uploading what we have so far. By the end of the term, we want our work to be available in a publically viewable location, complete with repository. We have that right now, to some extent, but clean-up must occur before we can actually “publish”.
  4. Implement with 2 more parallel systems. I’m using a product called LinuxTuples and Andrew’s using OpenMP.

I’m finding tuple spaces to be really interesting, and very theoretically pleasing. The performance seems to be decent too, and it seems like every problem fits into a nice box. More on that later.

Eve has, as one can probably tell from the sorry state of this page, come to a standstill. I’ll need to re-evaluate and make some less lofty (read: attainable) goals and an actual roadmap. When I get time to work on it, I’ll post more.

Today, Greg challenged the entire consulting course to come up with a novel book idea that relates to teaching computer scientists something relevant. What would I like to see? A book that shows how to marry imperative and “alternative” programming languages, so that we can e.g. do our AI in prolog while still being able to write our game engine in an imperative language. Alternatively, how does a developer go about accessing a library from a language for which no binding (API) is available? The question has been answered for most imperative languages through some kind of “our datatypes” => C datatypes conversion and access of native libraries, but what about using, say, Cairo under Haskell (lazy evaluation, remember)?

The basic question is this: how do we convince someone to move to a new language if nothing they already use works there? The question is there because the “best” way to do these things would not be using Eiffel+OpenGL, but some sort of Eiffel Graphics implementation. Or possibly even leveraging the programming language itself to distribute over all available processing units (standard 3D acceleration would come from the language knowing the GPU is best at matrix operations, data-parallel, etc.).

I guess the point is we don’t live in a perfect world, so if we want to leverage any of the power of these alternatives we’re going to have to interface with the more popular languages. That’s where this book comes in.

Who’s writing this?

My name is Cameron Gorrie. I'm an undergraduate student at the University of Toronto, with a strong interest in Artificial Intelligence and Computer Graphics. You can read more about me, or read my CV. If you have work or research opportunities in my interest areas, please do not hesitate to contact me.
April 2021