Changeset 14496 for docs/Perl6/Spec

Timestamp:

10/24/06 17:20:23 (2 years ago)

Author:

audreyt

svk:copy_cache_prev:

21659

Message:

* Perl6::Spec::Concurrency: Update nomenclature.

Files:

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

docs/Perl6/Spec/Concurrency.pod

@@ -103 +103 @@
 the BEGIN TRANSACTION was executed.
 
-Perl 6 supports this concept through Code blocks which are marked "is atomic".
+Perl 6 supports this concept through C<contend> blocks.
+
 These sections are guaranteed to either be completed totally (when the Code
 block is exited), or have their state reverted to the state at the start of
-the Code block (with the L<retry> statement).
+the Code block (with the L<defer> statement).
 
 (EM: maybe point out if / how old style locks can be "simulated", for those
@@ -114 +115 @@
 
     my ($x, $y);
-    sub c is atomic {
+    sub c { contend {
         $x -= 3;
         $y += 3;
-        if $x < 10 { retry }
-    };
-
-    $e = &c.retry_with( &d ); # 
-    $e();
-
-    if $i { is atomic; ...  } else { ...; }
-
-A Code block can be marked as "is atomic".  This means that code executed
+        if $x < 10 { defer }
+    } };
+
+    maybe { c() } maybe { d() };
+
+    if $i { contend { ...}  } else { ...; }
+
+A Code block can be prefixed with C<contend>.  This means that code executed
 inside that scope is guaranteed not to be interrupted in any way.
 
-The start of a block marked "is atomic" also becomes a "checkpoint" to
+The start of a block marked C<contend> also becomes a I<checkpoint> to
 which execution can return (in exactly the same state) if a problem occurs
-(a.k.a. a L<retry> is done) inside the scope of the Code block.
-
-=head3 retry
-
-The C<retry> function basically restores the state of the thread at the
+(a.k.a. a L<defer> is done) inside the scope of the Code block.
+
+=head3 defer
+
+The C<defer> function basically restores the state of the thread at the
 last checkpoint and will wait there until an external event allows it to
-potentially run that atomic section of code again without having to retry
-again.
+potentially run that atomic C<contend> section of code again without having
+to defer again.
 
 If there are no external events possible that could restart execution, an
 exception will be raised.
 
-The last checkpoint is either the last atomic / non-atomic boundary, or
-the most immediate caller constructed with C<retry_with>.
-
-=head3 retry_with
-
-The C<retry_with> method on an atomic Code object causes a checkpoint to
-be made for C<retry>, creating an alternate execution path to be followed
-when a C<retry> is done.
+The last checkpoint is either the outermose C<contend> boundary, or
+the most immediate caller constructed with C<maybe>.
+
+=head3 maybe
+
+The C<maybe> statement causes a checkpoint to be made for C<defer> for
+each block in the C<maybe> chain, creating an alternate execution path to
+be followed when a C<defer> is done.  For example:
+
+    maybe {
+        ...
+        some_condition() or defer;
+        ...
+    } maybe {
+        ...
+        some_other_condition() or defer;
+        ...
+    } maybe {
+        ...
+    }
+
+If placed outside a C<contend> block, the C<maybe> statement creates its
+own C<contend> barrier.
 
 =head3 limitations
@@ -180 +195 @@
 A Code block marked "is critical" can not be interrupted in any way.  But
 since it is able to access non-revertible data structures (such as
-non-seekable file handles), it cannot do a C<retry> as it would be impossible
+non-seekable file handles), it cannot do a C<defer> as it would be impossible
 to restore the state to the beginning of the Code block.
 
@@ -294 +309 @@
         # if the counter with the "key" equals or exceeds a closure's limit,
         # the closure can't be entered until it's released
-        # (this can be trivially implmented using atomic+retry)
+        # (this can be trivially implmented using contend+defer)
     }
 
@@ -328 +343 @@
 {
 
-    is atomic;   # retry/orelse/whatever other rollback stuff
+    is atomic;   # contend/maybe/whatever other rollback stuff
                  # limitation: no external IO (without lethal warnings anyway)
                  # can't do anything irreversible