Changeset 20063 for docs

Timestamp:

03/05/08 00:04:41 (10 months ago)

Author:

buchetc

Message:

[Spec] start re-oraginze S17

Files:

• docs/Perl6/Spec/Concurrency.pod (modified) (14 diffs)

docs/Perl6/Spec/Concurrency.pod

@@ -3 +3 @@
 =head1 TITLE
 
-Synopsis 17: Concurrency [DRAFT]
+DRAFT: Synopsis 17: Concurrency
 
 =head1 AUTHOR
 
- Elizabeth Mattijsen <liz@dijkmat.nl>
- Audrey Tang <audreyt@audreyt.org>
+Elizabeth Mattijsen <liz@dijkmat.nl>
+Audrey Tang <audreyt@audreyt.org>
 
 =head1 VERSION
 
- Maintainer: Elizabeth Mattijsen <liz@dijkmat.nl>
- Date: 13 Jun 2005
- Last Modified: 08 Feb 2008
- Number: 0
- Version: 2
-
-=head1 SKETCH
-
-This is a rough sketch of how concurrency works in Perl 6.
-
-(actually these are just random notes, put here under the release-early
-release-often principle, slowly being integrated in a more textual format.
-Patches welcome!)
-
-=head1 OVERVIEW
+ Maintainer:    Elizabeth Mattijsen <liz@dijkmat.nl>
+ Contributions: Christoph Buchetmann
+ Date:          13 Jun 2005
+ Last Modified: 4 Mar 2008
+ Number         0
+ Version:       3
+
+This is a draft document. After being some time under the surface of Perl 6
+development this is a attempt to document working concurrency issues, list the
+remaining todos and mark the probably obsolete and redundant points.
+
+=head1 Overview
 
 Concurrency can take many forms in Perl 6.  With varying degrees of
@@ -83 +80 @@
 access inside a thread, except for those with an explicit "is shared"
 attribute?)
+
+=head1 Contend/Maybe/Defer
 
 =head2 No user accessible locks
@@ -187 +186 @@
 uninterruptability, you could use the "is critical" trait.
 
-=head2 Critical Code blocks
+=head3 Critical Code blocks
 
  sub tricky is critical {
@@ -203 +202 @@
 to restore the state to the beginning of the Code block.
 
-=head2 Mixing Atomic and Critical
+=head3 Mixing Atomic and Critical
 
 Both "atomic" as well as "critical" propagate down the call chain.  This means
@@ -217 +216 @@
 of an Atomic Code block.
 
-=head2 Co-Routines
-
- sub foo {
-    my @list = ( 1, 11, 17 );
-    while (@list) {
-        @list.shift.produce;
-    }
-    return;
- }
-
- say foo; # 1
- say foo; # 11
- say foo; # 17
- say foo; # undef
- say foo; # 1
+
+=head1 Co-Routines
 
 There is no real difference between a subroutine (or method) and a so-called
@@ -259 +245 @@
 the use of named parameters is therefore advisable.
 
-=head2 Threads
-
-
-=head3 Kill all
-
-   CORE::GLOBAL::exit; # kills all the threads
-
-
-=head3 Thread models 
+=head2 Examples
+
+  coro dbl { yield $_ * 2; yield $_; };
+  (1..4).map:{ dbl($_) }
+  # should result in 2 2 6 4
+
+
+
+=head1 Threads
+
+=head2 Thread methods and attributes
 
 We intentionally do not list cross-machine parallelism Conc:: classes here.
@@ -284 +272 @@
    Conc::Proc.this
 
-=head3 Thread methods and attributes
-
-Conc object # name is still up for grabs!
 
  - numify to TIDs (as in pugs)
@@ -335 +320 @@
 
 
-=head3 Thread status
-
-- IO objects and containers gets concurrency love!
+=head2 Thread status
+
+ -IO objects and containers gets concurrency love!
     - $obj.wake_on_readable
     - $obj.wake_on_writable
@@ -348 +333 @@
     async { @a.unshift({ ... }) };
 
-Communication abstractions
-- shared, transactional variables by default
+ Communication abstractions
+ - shared, transactional variables by default
 
 # program will wait for _all_ threads
@@ -355 +340 @@
 # of the parent thread that spawned them
 
-
-=head2 Still more or less unorganized stuff
-
-
-### INTERFACE BARRIER ###
-module Blah;
-{
-
-    is atomic;   # contend/maybe/whatever other rollback stuff
-                 # limitation: no external IO (without lethal warnings anyway)
-                 # can't do anything irreversible
-
-    is critical; # free to do anything irreversible
-                 # means "don't interrupt me"
-                 # in system with critical section, no interrupts from
-                 # other threads will happen during execution
-                 # you can't suspend me
-
-    my $boo is export;
-    $boo = 1;
-
-    # We decree that this part forms the static interface
-    # it's run once during initial compilation under the
-    # Separate Compilation doctrine and the syms sealed off
-    # to form part of bytecode syms headers
-    %CALLER::<&blah> = { 1 }; # work - adds to export set
-    die "Eureka!" if %CALLER::<$sym>; # never dies
-
-    # BEGIN { $boo = time };
-
-    sub IMPORT {
-        # VERY DYNAMIC!
-
-        our $i = time;
-        %CALLER::<&blah> = { 1 }; # work - adds to export set
-        die "Eureka!" if %CALLER::<$sym>; # probes interactively
-    }
-}
-### INTERFACE BARRIER ###
-
-my $sym;
-threads.new({
-    use Blah;
-    BEGIN { require(Blah).import }
-
-    my $boo; BEGIN { eval slurp<Blah.pm>; $boo := $Blah::boo };
-
-    ...
-});
 
 =head2 Signals
@@ -484 +420 @@
 =head2 Continuations
 
-=head3 Coroutines
-
-## braindump of coro meeting by Liz and Autri, more to follow
+=head2 Junctive Autothreading and Hyper Operations
+
+Live in userland for the time being.
+
+=head2 Interprocess Communication
+
+=head2 I/O Considerations
+
+=head3 File Descriptors
+
+=head3 Sockets
+
+
+=head2 Still more or less unorganized stuff
+
+
+### INTERFACE BARRIER ###
+module Blah;
+{
+
+    is atomic;   # contend/maybe/whatever other rollback stuff
+                 # limitation: no external IO (without lethal warnings anyway)
+                 # can't do anything irreversible
+
+    is critical; # free to do anything irreversible
+                 # means "don't interrupt me"
+                 # in system with critical section, no interrupts from
+                 # other threads will happen during execution
+                 # you can't suspend me
+
+    my $boo is export;
+    $boo = 1;
+
+    # We decree that this part forms the static interface
+    # it's run once during initial compilation under the
+    # Separate Compilation doctrine and the syms sealed off
+    # to form part of bytecode syms headers
+    %CALLER::<&blah> = { 1 }; # work - adds to export set
+    die "Eureka!" if %CALLER::<$sym>; # never dies
+
+    # BEGIN { $boo = time };
+
+    sub IMPORT {
+        # VERY DYNAMIC!
+
+        our $i = time;
+        %CALLER::<&blah> = { 1 }; # work - adds to export set
+        die "Eureka!" if %CALLER::<$sym>; # probes interactively
+    }
+}
+### INTERFACE BARRIER ###
+
+=head3 braindump of coro meeting by Liz and Autri, more to follow
 
 - Coros are _like_ processes
 
-coro dbl { yield $_ * 2; yield $_; return };
-my @x = 1..10;
-my %y = map &dbl, @x;
-# 2 => 2, 6 => 4, 10 => 6, ...
-
-coro perm (@x) {
-    @x.splice(rand(@x),1).yield while @x;
-}
-
-my &p1 := &perm.start(1..10);
-my &p2 := &perm.start(1..20);
-
-p1(); p1();
-p2(); p2();
-
-coro foo { yield 42 };
-
-(1..10).pick;
-
-coro foo ($x) {
+  coro perm (@x) {
+     @x.splice(rand(@x),1).yield while @x;
+  }
+  my &p1 := &perm.start(1..10);
+  my &p2 := &perm.start(1..20);
+  p1(); p1();
+  p2(); p2();
+
+  coro foo { yield 42 };
+
+  coro foo ($x) {
     yield $x;
     yield $x+2;
@@ -518 +495 @@
         }
     }
-} # implicit falloff return + return() means start over without yielding
-  # return() means yielding and restart + no implicit falloff (I LIKE THIS)
-
-&foo.finished; # true on return() and false on midway yield()
-
-foo(4); # and that's all she wrote
-
-coro foo ($x) {
+  } # implicit falloff return + return() means start over without yielding
+    # return() means yielding and restart + no implicit falloff (I LIKE THIS)
+
+  &foo.finished; # true on return() and false on midway yield()
+
+  foo(4); # and that's all she wrote
+
+  coro foo ($x) {
     yield $x;
     # this point with $x bound to 10
@@ -531 +508 @@
     return 5;
     ... # this is never reached, I think we all agree
-}
-
-# If you don't want your variables to get rebound, use "is copy":
-coro foo ($x is copy) {...}
-# which is sugar for
-coro foo ($x) {
-  {
-    my $x := $OUTER::x;
-    ...;
-    # Further calls of &foo rebound $OUTER::x, not $x.
-  }
-}
-
-sub foo {
-    return undef if rand;
-    ...
-}
-
-use overload {
+  }
+
+  # If you don't want your variables to get rebound, use "is copy":
+  coro foo ($x is copy) {...}
+  # which is sugar for
+  coro foo ($x) {
+    {
+      my $x := $OUTER::x;
+      ...;
+      # Further calls of &foo rebound $OUTER::x, not $x.
+    }
+  }
+
+  sub foo {
+     return undef if rand;
+     ...
+  }
+
+  use overload {
     '&{}' => sub { ... }
-}
-
-class Coro is Conc::Multiplex does Code {
-    method postcircumfix:<( )> {
-        # start the thread, block stuff (we are in the caller's context)
-    }
-}
-
-class Hash is extended {
+  }
+
+  class Coro is Conc::Multiplex does Code {
+     method postcircumfix:<( )> {
+         # start the thread, block stuff (we are in the caller's context)
+     }
+  }
+
+  class Hash is extended {
     method postcircumfix:<( )> (&self: *@_) {
         &self = self.start(@_);
@@ -567 +544 @@
         # upon return() or normal falloff, restore self
     }
-}
-
-%*ENV(123);
-
-&foo_continued := &foo.start(10);
-&foo.start(20);
-
-foo(10);    # returns 10
-
-foo();      # be "insufficient param" error or just return 11?
-foo(20);    # returns 21
-
-# continuation coros
-multi foo () { ...no rebinding... }
-multi foo ($x) { ...rebinding... }
-
-&foo.kill;
-
-
-my $first_ret = zoro( type => <even> );
-&zoro.variant(:type<even>).kill;
-&zoro.variant(type => 'even').kill;
-
-zoro( type => <odd> );
-
-zoro( even => 1 );
-zoro( odd => 1 );
-
-multi coro zoro ($type where 'even') {}
-multi coro zoro ($type where 'odd') {}
-
-multi coro zoro ($even is named) {}
-multi coro zoro ($odd is named) {}
-
-
-# iblech's thoughts:
-# Coroutine parameters should never be rebound. Instead, yield(...)s return
-# value is an Arglist object containing the new arguments:
-coro bar ($a, $b) {
+  }
+
+  %*ENV(123);
+
+  &foo_continued := &foo.start(10);
+  &foo.start(20);
+
+  foo(10);    # returns 10
+
+  foo();      # be "insufficient param" error or just return 11?
+  foo(20);    # returns 21
+
+  # continuation coros
+  multi foo () { ...no rebinding... }
+  multi foo ($x) { ...rebinding... }
+
+  &foo.kill;
+
+
+  my $first_ret = zoro( type => <even> );
+  &zoro.variant(:type<even>).kill;
+  &zoro.variant(type => 'even').kill;
+
+  zoro( type => <odd> );
+
+  zoro( even => 1 );
+  zoro( odd => 1 );
+
+  multi coro zoro ($type where 'even') {}
+  multi coro zoro ($type where 'odd') {}
+
+  multi coro zoro ($even is named) {}
+  multi coro zoro ($odd is named) {}
+
+
+  # iblech's thoughts:
+  # Coroutine parameters should never be rebound. Instead, yield(...)s return
+  # value is an Arglist object containing the new arguments:
+  coro bar ($a, $b) {
     ...;
     my $new_set_of_args = yield(...);
     my $sum_of_old_a_and_new_a = $a + $new_set_of_args<$a>;
     ...;
-}
-bar(42, 23);  # $a is 42, $b is 23
-bar(17, 19);  # $a still 42, $b still 19,
-              # $new_set_of_args is \(a => 17, b => 19)
-
-=head2 Junctive Autothreading and Hyper Operations
-
-Live in userland for the time being.
-
-=head2 Interprocess Communication
-
-=head2 I/O Considerations
-
-=head3 File Descriptors
-
-=head3 Sockets
+  }
+  bar(42, 23);  # $a is 42, $b is 23
+  bar(17, 19);  # $a still 42, $b still 19,
 
 =cut
+