Parallel Computing

[j0ni]

Hey Cmdln

I listened to your interview with Ed Felten yesterday - excellent
inteview, thanks. I was a little surprised that he didn't jump on the
parallel computing question a bit more. Seems to me that SMP and (more
significantly) CMP architectures have spawned new kinds of attacks and
vulnerabilities.

I thought you might be interested in this paper (which I found through
Randal Schwartz's blog), "The Problem With Threads", by Edward A Lee.
It talks about how our current mainstream programming models
("paradigms") are inherently unsuitable for concurrent programming -
the notion is that we currently write concurrent code which is non-
deterministic and attempt to "prune" the non-determinism by deploying
mutexes (sp?) etc., a technique which cannot yield a deterministic
solution, and therefore inevitably produces bugs. (And of course bugs
=> vulnerabilities.)

I think it's a great paper. Check it out:
http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-1.pdf

cheers, J

[Command Line]

On Sat, Mar 29, 2008 at 2:24 PM, j0ni <diaz...@gmail.com> wrote:
>
> I listened to your interview with Ed Felten yesterday - excellent
> inteview, thanks. I was a little surprised that he didn't jump on the
> parallel computing question a bit more. Seems to me that SMP and (more
> significantly) CMP architectures have spawned new kinds of attacks and
> vulnerabilities.

Drat, that angle hadn't occurred to me either. In retrospect, it is
kind of obvious, isn't it, given his current and past interests. Glad
you enjoyed the interview, regardless.

> I thought you might be interested in this paper (which I found through
> Randal Schwartz's blog), "The Problem With Threads", by Edward A Lee.
> It talks about how our current mainstream programming models
> ("paradigms") are inherently unsuitable for concurrent programming -
> the notion is that we currently write concurrent code which is non-
> deterministic and attempt to "prune" the non-determinism by deploying
> mutexes (sp?) etc., a technique which cannot yield a deterministic
> solution, and therefore inevitably produces bugs. (And of course bugs
> => vulnerabilities.)
>
> I think it's a great paper. Check it out:
> http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-1.pdf

Thanks for the link, this is definitely a topic that fascinates me.
As my challenges become more complex in my day to day programming
work, writing lower level, closer to systems code, I can certainly
appreciate that sense that mutual exclusion is a bit at odds with what
would feel like more natural, better optimized concurrent code.

I look forward to reading the paper. Thanks, again.

cmdln
--
The Command Line Podcast
2007 Parsec Award Winner for Best Tech Podcast
http://thecommandline.net/
Open Media Review, Contributing Editor
http://openmediareview.com/