• dsimcha (10/10) Apr 16 2011 I'm reconsidering the naming of std.parallelism. The name is catchy,
• Andrei Alexandrescu (3/13) Apr 16 2011 I don't mind std.parallelism one bit.
• Andrej Mitrovic (1/1) Apr 16 2011 std.multicore? :p
• Dmitry Olshansky (8/19) Apr 16 2011 I'm inclined to go with std.parallelism, the name is so cute :).
• Gary Whatmore (2/20) Apr 17 2011 I'd vote for std.parallel.smp and std.parallel.simd. But Phobos does not...
• Michel Fortin (10/21) Apr 16 2011 While "parallelism" might be too general, isn't it true that it's too

dsimcha <dsimcha yahoo.com> writes:

I'm reconsidering the naming of std.parallelism.  The name is catchy, 
but perhaps too general.  std.parallelism currently targets SMP 
parallelism.  In the future it would be nice for Phobos to target SIMD 
parallelism and distributed message passing parallelism, too.  These 
might belong in different modules.  Then again, std.smp or std.multicore 
or something just doesn't sound as catchy.  SIMD would probably just be 
array ops and stuff.  Distributed message passing would probably be 
absorbed by std.concurrency since the distinction between concurrency 
and parallelism isn't as obvious at this level and std.concurrency is 
already the home of message passing stuff.  Please comment.

Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:

On 4/16/11 1:39 PM, dsimcha wrote:
 I'm reconsidering the naming of std.parallelism. The name is catchy, but
 perhaps too general. std.parallelism currently targets SMP parallelism.
 In the future it would be nice for Phobos to target SIMD parallelism and
 distributed message passing parallelism, too. These might belong in
 different modules. Then again, std.smp or std.multicore or something
 just doesn't sound as catchy. SIMD would probably just be array ops and
 stuff. Distributed message passing would probably be absorbed by
 std.concurrency since the distinction between concurrency and
 parallelism isn't as obvious at this level and std.concurrency is
 already the home of message passing stuff. Please comment.

I don't mind std.parallelism one bit.

Andrei

Andrej Mitrovic <andrej.mitrovich gmail.com> writes:

std.multicore? :p

Dmitry Olshansky <dmitry.olsh gmail.com> writes:

On 16.04.2011 22:39, dsimcha wrote:
 I'm reconsidering the naming of std.parallelism.  The name is catchy, 
 but perhaps too general.  std.parallelism currently targets SMP 
 parallelism.  In the future it would be nice for Phobos to target SIMD 
 parallelism and distributed message passing parallelism, too.  These 
 might belong in different modules.  Then again, std.smp or 
 std.multicore or something just doesn't sound as catchy.  SIMD would 
 probably just be array ops and stuff.  Distributed message passing 
 would probably be absorbed by std.concurrency since the distinction 
 between concurrency and parallelism isn't as obvious at this level and 
 std.concurrency is already the home of message passing stuff.  Please 
 comment.

I'm inclined to go with std.parallelism, the name is so cute :).
On the serious side of it, I think SIMDs  really belong to compiler 
internals and std.intrinsics.
And any message passing should most likely go into std.concurency, even 
though that lives some scenarios somewhat on the edge of two (parallelism).


-- 
Dmitry Olshansky

Gary Whatmore <no spam.sp> writes:

Dmitry Olshansky Wrote:

 On 16.04.2011 22:39, dsimcha wrote:
 I'm reconsidering the naming of std.parallelism.  The name is catchy, 
 but perhaps too general.  std.parallelism currently targets SMP 
 parallelism.  In the future it would be nice for Phobos to target SIMD 
 parallelism and distributed message passing parallelism, too.  These 
 might belong in different modules.  Then again, std.smp or 
 std.multicore or something just doesn't sound as catchy.  SIMD would 
 probably just be array ops and stuff.  Distributed message passing 
 would probably be absorbed by std.concurrency since the distinction 
 between concurrency and parallelism isn't as obvious at this level and 
 std.concurrency is already the home of message passing stuff.  Please 
 comment.

 
 I'm inclined to go with std.parallelism, the name is so cute :).
 On the serious side of it, I think SIMDs  really belong to compiler 
 internals and std.intrinsics.
 And any message passing should most likely go into std.concurency, even 
 though that lives some scenarios somewhat on the edge of two (parallelism).

I'd vote for std.parallel.smp and std.parallel.simd. But Phobos does not
support deep nested package names, which is good. Otherwise the naming would be
a hell on earth just like Java or Tango.

Michel Fortin <michel.fortin michelf.com> writes:

On 2011-04-16 14:39:23 -0400, dsimcha <dsimcha yahoo.com> said:

 I'm reconsidering the naming of std.parallelism.  The name is catchy, 
 but perhaps too general.  std.parallelism currently targets SMP 
 parallelism.  In the future it would be nice for Phobos to target SIMD 
 parallelism and distributed message passing parallelism, too.  These 
 might belong in different modules.  Then again, std.smp or 
 std.multicore or something just doesn't sound as catchy.  SIMD would 
 probably just be array ops and stuff.  Distributed message passing 
 would probably be absorbed by std.concurrency since the distinction 
 between concurrency and parallelism isn't as obvious at this level and 
 std.concurrency is already the home of message passing stuff.  Please 
 comment.

While "parallelism" might be too general, isn't it true that it's too 
specific at the same time? I mean, the module includes a concurrent 
task system, some sugar to parallelize loops using tasks (foreach, map, 
reduce), and an async buffer implementation also based on tasks. Of 
those, which are truly parallelism?


-- 
Michel Fortin
michel.fortin michelf.com
http://michelf.com/