[gclist] Re: gclist-digest V3 #84

[Nathan Inada]

  Lee> Any implementation can avoid inter-thread pointers if all
  Lee> inter-thread communications have deep-copy semantics.  This is
  Lee> limiting of course (and impossible unless deep-copy is
  Lee> implemented or just mandated), but it solves a lot of problems
  Lee> such as this and it makes trivial extending the system to true
  Lee> distributed processing.

[Please forgive my newness to this all...]
Some paper, i think Wilson's Garbage Collection Survey, makes the 
point that the practice of copying memory areas to keep module
local control has both the physical copy overhead as well as a
subtler, perhaps unmeasurable, program design impact.
I believe the paper was only addressing modularity within single
threaded programs, however, but it seems like the analogy of module
awareness (keep my owh copy) vs global program awareness (program wide
garbage collection) extends to threads and true distributed
processing.

My questions are:

  Have there been any "measures" of the program/system design impact
  of the "keep my own copy" practice?

  Is it the case that the jump in access/reference overhead across
  threads/processes/machines tips the first order balance towards a
  version of "keep my own copy"?
  And the programatic design impact is not a factor if the deep-copy
  is all done under the covers?

I hope these questions are not completely nonsensical.

Thanks
nathan