<div dir="ltr"><br><br>
<div class="gmail_quote">2008/9/9 Bruce Eckel <span dir="ltr">&lt;<a href="mailto:bruceteckel@gmail.com">bruceteckel@gmail.com</a>&gt;</span><br>
<blockquote style="BORDER-LEFT: #ccc 1px solid; MARGIN: 0px 0px 0px 0.8ex; PADDING-LEFT: 1ex" class="gmail_quote">
<div dir="ltr">So this is the kind of problem I keep running into. There will seem to be consensus that you can do everything with isolated processes message passing (and note here that I include Actors in this scenario even if their mechanism is more complex). And then someone will pipe up and say &quot;well, of course, you have to have threads&quot; and the argument is usually &quot;for efficiency.&quot; 
<div><br></div>
<div>I make two observations here which I&#39;d like comments on:</div>
<div><br></div>
<div>1) What good is more efficiency if the majority of programmers can never get it right? My position: if a programmer has to explicitly synchronize anywhere in the program, they&#39;ll get it wrong. This of course is a point of contention; I&#39;ve met a number of people who say &quot;well, I know you don&#39;t believe it, but *I* can write successful threaded programs.&quot; I used to think that, too. But now I think it&#39;s just a learning phase, and you aren&#39;t a reliable thread programmer until you say &quot;it&#39;s impossible to get right&quot; (yes, a conundrum).</div>

<div></div></div></blockquote>
<div>&nbsp;</div>
<div>&nbsp;</div>
<div>I don&#39;t see why this needs to be a religious either-or issue? As I said, *when* isolated threads maps well to your problem, they are more attractive than shared memory solutions (for correctness reasons), but preferring isolated threads does not mean you should ignore the reality that they do not fit every scenario well. There&#39;s no single superior concurrency/parallelism paradigm (at least not yet), so the best we can do for general purpose languages is to recognize the relative strengths/weaknesses of each and provide all of them.</div>

<div>&nbsp;</div>
<blockquote style="BORDER-LEFT: #ccc 1px solid; MARGIN: 0px 0px 0px 0.8ex; PADDING-LEFT: 1ex" class="gmail_quote">
<div dir="ltr">
<div><span></span><br></div>
<div>2) What if you have lots of processors? Does that change the picture any? That is, if you use isolated processes with message passing and you have as many processors as you want, do you still think you need shared-memory threading?</div>
</div></blockquote>
<div>&nbsp;</div>
<div>Not really. There are still situations where you have large pools of *potential* data with no way of figuring out ahead of time what pieces you&#39;ll need to modify . So for explicit synchronisation, e.g. using isolated threads to &quot;own&quot; the data, or with locks, you&#39;ll need to be conservative and lock the whole world, which means you might as well run everything sequentially. Note here that implementing this scenario using isolated threads with message passing effectively boils down to simulating locks and shared memory - so if you&#39;re using shared memory and locks anyway, why not have native (efficient) support for them?</div>

<div>&nbsp;</div>
<div>As I said earlier, though, I believe the best way to synchronize shared memory is currently STM, not using manual locks (simulated with threads or otherwise).</div>
<div>&nbsp;</div>
<blockquote style="BORDER-LEFT: #ccc 1px solid; MARGIN: 0px 0px 0px 0.8ex; PADDING-LEFT: 1ex" class="gmail_quote">
<div dir="ltr">
<div><span></span></div>
<div><br></div>
<div>A comment on the issue of serialization -- note that any time you need to protect shared memory, you use some form of serialization. Even optimistic methods guarantee serialization, even if it happens after the memory is corrupted, by backing up to the uncorrupted state. The effect is the same; only one thread can access the shared state at a time. 
<div>
<div></div>
<div class="Wj3C7c"></div></div></div></div></blockquote>
<div>&nbsp;</div>
<div>&nbsp;</div>
<div>Yes, the difference is that with isolated threads, or with manual locking, the programmer has to somehow figure out which pieces lock ahead of time, or write manual transaction protocols with rollbacks etc. The ideal case is that you have a runtime (possibly with hardware support) to let you off the hook and automatically do a very fine-grained locking with optimistic concurrency.</div>

<div>&nbsp;</div>
<div>Isolated threads and locks are on the same side of this argument - they both require the user to ahead of time partition the data up and decide how to serialize operations on the data (which is not always possible statically, leading to very very complicated code, or very low concurrency).<br clear="all">
<br>-- <br>Sebastian Sylvan<br>+44(0)7857-300802<br>UIN: 44640862<br></div></div></div>