Differences

This shows you the differences between two versions of the page.

--- at:tutorial:appendix [2008/07/10 15:42] – added tvcutsem
+++ at:tutorial:appendix [2008/07/10 16:12] – * tvcutsem
@@ Line 389: / Line 389: @@
 ==== Futures and Multifutures ====
+=== Futures ===
+The module ''/.at.lang.futures'' provides support for futures. Futures have already been described as part of the [[concurreny|concurrency]] section in the tutorial.
+The module exports the type tags ''OnewayMessage'', ''FutureMessage'' and ''Due'':
+  * Tagging an asynchronous message with ''FutureMessage'' will attach a future to the message.
+  * Tagging a message with ''OnewayMessage'' ensures no future will ever be attached to the message.
+  * Tagging a message with ''@Due(timeout)'' associates a future with the message that is automatically ruined with a ''TimeoutException'' after the given ''timeout'' period (in milliseconds) has elapsed.
+Messages can be automatically associated with a future by invoking the ''enableFutures()'' function, which enables futures for all messages, except those tagged as a ''OnewayMessage''.
+The futures module also exports the function ''when:becomes:'' to await the resolution of a future, and auxiliary ''when:becomes:catch:using:'' functions.
+Futures can also be created and resolved manually:
+<code>
+import /.at.lang.futures;
+def [fut, res] := makeFuture();
+when: someAsynchronousComputation() becomes: { |value|
+  res.resolve(value); // resolve the future manually
+}
+fut // return the future to a client
+</code>
+Finally, the futures module also provides some auxiliary functions, of which ''group:'' is often a very useful one. The ''group:'' construct groups a table of futures into a single future which is resolved with a table of values or ruined with an exception:
+<code>
+when: (group: [ a<-m(), b<-n() ]) becomes: { |values|
+  def [aResult, bResult] := values;
+  ...
+}
+</code>
+=== Multifutures ===
+The module ''/.at.lang.multifutures'' provides support for multifutures. A multifuture is a future that can be resolved multiple times. We distinguish between 'bounded multifutures', which can be resolved up to a maximum number and 'unbounded multifutures' which have no upper bound.
+A multifuture is constructed as follows:
+<code>
+def [mf, resolver] := makeMultiFuture(n, timeout);
+</code>
+The parameter ''n'' indicates the maximum number of values/exceptions with which the future can be resolved/ruined. If ''n'' is ''nil'', the multifuture is unbounded. The timeout parameter is optional. If not nil, it is a timeout period in milliseconds that causes the multifuture to //automatically// become fully resolved after the provided timeout. Once fully resolved, a multifuture will not accept any new values/exceptions, even if it has not reached its "upper bound" ''n'' yet.
+A multifuture accepts the following listeners:
+<code>
+whenEach: multiFuture becomes: { |val| ... }
+</code>
+The above listener is invoked whenever the future is resolved with a new value. Its code can thus be executed multiple times.
+<code>
+whenAll: multiFuture resolved: { |values|
+  ...
+} ruined: { |exceptions| ... }
+</code>
+The above listener is invoked if all results have been gathered (only possible if the maximum number of results is known) or when the ''timeout'' period associated with the future has elapsed. ''values'' refers to a table of all resolved values. If there are no exceptions, only the first code block is triggered. If there are only exceptions, the first block is still invoked with an empty table.
+Note the following properties of multifutures:
+  * It is allowed to register a whenAll:resolved:ruined: listener an 'unbounded' multifuture. However, for such multifutures, this listener will only trigger if a timeout was specified during the multifuture's creation. The listener is invoked upon timeout, and later incoming results are discarded.
+  * As with futures, it is legal to send asynchronous messages to the multifuture, which are in turn propagated to all resolved values. If some values are ruined, asynchronous messages containing a multifuture are ruined. Hence, exceptions only propagate through a pipeline of multifutures.
+  * When a multifuture A is resolved with a multifuture B, all of B's eventual values/exceptions become values/exceptions of A.
+  * A whenEach:becomes: observer automatically returns a multifuture itself. This multifuture has the same arity as the original and is resolved/ruined with the return values of the multiple invocations of the becomes: or catch: closures.
+  * Like with futures, multifutures can be explicitly created, e.g.:
+<code>def [ multifut, resolver ] := makeMultiFuture(upperBound);</code>
+  * Multifutures can be attached to messages by annotating an asynchronous message with the @Gather(n) type tag.
+  * Adding a when:becomes: listener on a multifuture is allowed but only triggers for the first value/exception of the multifuture. This allows multifutures to be used wherever regular futures are expected.
+The multifutures module also exports an abstraction known as a "multireference". The expression ''multiref: [ ref1, ref2,... ]'', where ''refi'' are far references, returns a multireference. Any message sent to a multireference is sent to all constituent references, and a multifuture is returned which can trap the results.
+When the message sent to a multireference is annotated with @Due(t), the timeout is applied to the implicit multifuture, causing whenAll observers to trigger automatically. Note that the implicit multifuture of a multireference is bounded, so whenAll observers trigger automatically when all replies have been received.
 ==== Dynamic Variables ====
@@ Line 397: / Line 470: @@
 ==== Traits ====