Add a future data type for concurrent and parallel programming

library/library.m:
library/thread.future.m:
library/thread.m:
    Add new future standard library module.

NEWS:
    Announce the new addition.

library/thread.semaphore.m:
    Add an impure interface to thread.semaphore.m.  Semaphores are used to
    implement our other concurrency primitives and an impure interface can
    often be useful to implement things such as futures, which don't require
    IO state threading.  The impure interface predicate names are prefixed
    with "impure_".

library/thread.semaphore.m:
NEWS:
    Deprecate the impure init/1 function.

library/thread.mvar.m:
    Conform to changes in semaphore.m.

benchmarks/progs/mandelbrot/mandelbrot.m:
    Add future example to mandelbrot benchmark.

Author: PaulBone

NEWS

@@ -24,12 +24,18 @@ Changes to the Mercury standard library:
   highly efficient set implementation for fat sets.  This module is a
   contribution from Yes Logic Pty. Ltd.
 
-* We have added a module that implements barriers for concurrent
-  programming.  This module is a contribution from Mission Critical IT.
++ We have added two new modules for concurrent programming: thread.barrier
+  and thread.future.  The barrier module provides a barrier type which can
+  be used to control progress in concurrent code.  The future module
+  provides future and future_io data types which can be used to compute
+  values in parallel using other threads.  These modules were contributed by
+  Mission Critical IT.
 
 * We have added thread.spawn_native/4 to dedicate an OS thread to a Mercury
   thread. thread.spawn/4 was added as well.
 
++ We have deprecated the impure init/1 function in thread.semaphore.
+
 * In C grades, the math module now provides the fused multiply-add operation
   on platforms that support it.
 

benchmarks/progs/mandelbrot/mandelbrot.m

@@ -21,6 +21,7 @@
 :- import_module require.
 :- import_module string.
 :- import_module thread.
+:- import_module thread.future.
 :- import_module thread.mvar.
 
 main(!IO) :-
@@ -115,6 +116,7 @@
     --->    parallel_conj
     ;       parallel_spawn
     ;       parallel_spawn_native
+    ;       parallel_future
     ;       sequential.
 
 :- pred process_options(option_table(option)::in, maybe_error(options)::out)
@@ -143,13 +145,16 @@
         ;
             ParallelStr = "spawn_native",
             Parallel0 = parallel_spawn_native
+        ;
+            ParallelStr = "future",
+            Parallel0 = parallel_future
         )
     ->
         MaybeParallel = ok(Parallel0)
     ;
         MaybeParallel = error(
-            "Parallel must be one of ""no"", ""conj"", ""spawn"" or " ++
-            """spawn_native""")
+            "Parallel must be one of ""no"", ""conj"", ""spawn"", " ++
+            """spawn_native"" or ""future""")
     ),
 
     getopt.lookup_maybe_int_option(Table, dim_x, MaybeX),
@@ -198,9 +203,11 @@
         "\t\tThe dimensions of the image, specify neither or both\n", !IO),
     write_string("\t-p <how> --parallel <how>\n", !IO),
     write_string(
-        "\t\t<how> is one of ""no"", ""conj"", ""spawn"" or\n", !IO),
+        "\t\t<how> is one of ""no"", ""conj"", ""spawn"",\n", !IO),
+    write_string(
+        "\t\t""spawn_native"" or ""future"". These may be grade", !IO),
     write_string(
-        "\t\t""spawn_native"". These may be grade dependent.\n", !IO),
+        "\t\tdependent.\n", !IO),
     write_string("\t-d --dependent-conjunctions\n", !IO),
     write_string(
         "\t\tUse an accumulator to represent the rows rendered so far\n", !IO).
@@ -241,14 +248,20 @@
 :- pred draw_rows_dep(parallel::in, list(float)::in, list(float)::in,
     cord(colour)::out) is det.
 
-draw_rows_dep(sequential, Xs, Ys, Rows) :-
-    map_foldl(draw_row(Xs), append_row, Ys, empty, Rows).
-draw_rows_dep(parallel_conj, Xs, Ys, Rows) :-
-    map_foldl_par_conj(draw_row(Xs), append_row, Ys, empty, Rows).
-draw_rows_dep(parallel_spawn, Xs, Ys, Rows) :-
-    map_foldl_par_spawn(draw_row(Xs), append_row, Ys, empty, Rows).
-draw_rows_dep(parallel_spawn_native, Xs, Ys, Rows) :-
-    map_foldl_par_spawn_native(draw_row(Xs), append_row, Ys, empty, Rows).
+draw_rows_dep(Parallel, Xs, Ys, Rows) :-
+    (
+        Parallel = sequential,
+        map_foldl(draw_row(Xs), append_row, Ys, empty, Rows)
+    ;
+        Parallel = parallel_conj,
+        map_foldl_par_conj(draw_row(Xs), append_row, Ys, empty, Rows)
+    ;
+        ( Parallel = parallel_spawn
+        ; Parallel = parallel_spawn_native
+        ; Parallel = parallel_future
+        ),
+        sorry($file, $pred, string(Parallel))
+    ).
 
 :- pred draw_rows_indep(parallel::in, list(float)::in, list(float)::in,
     cord(colour)::out) is det.
@@ -270,6 +283,9 @@
         promise_equivalent_solutions [RowList] (
             my_map_par_spawn_native(draw_row(Xs), Ys, RowList)
         )
+    ;
+        Parallel = parallel_future,
+        my_map_par_future(draw_row(Xs), Ys, RowList)
     ),
     foldl(append_row, RowList, empty, Rows).
 
@@ -375,22 +391,6 @@
         map_foldl_par_conj(M, F, Xs, !Acc)
     ).
 
-:- pred map_foldl_par_spawn(pred(X, Y), pred(Y, A, A), list(X), A, A).
-:- mode map_foldl_par_spawn(pred(in, out) is det, pred(in, in, out) is det,
-    in, in, out) is erroneous.
-
-map_foldl_par_spawn(_, _, _, !Acc) :-
-    % XXX: Do the parallel conjunction transformation by hand.
-    sorry($file, $pred, "Unimplemented").
-
-:- pred map_foldl_par_spawn_native(pred(X, Y), pred(Y, A, A), list(X), A, A).
-:- mode map_foldl_par_spawn_native(pred(in, out) is det,
-    pred(in, in, out) is det, in, in, out) is erroneous.
-
-map_foldl_par_spawn_native(_, _, _, !Acc) :-
-    % XXX: Do the parallel conjunction transformation by hand.
-    sorry($file, $pred, "Unimplemented").
-
 :- pred my_map(pred(X, Y), list(X), list(Y)).
 :- mode my_map(pred(in, out) is det, in, out) is det.
 
@@ -407,6 +407,16 @@
     M(X, Y) &
     my_map_par_conj(M, Xs, Ys).
 
+:- pred my_map_par_future(pred(X, Y), list(X), list(Y)).
+:- mode my_map_par_future(pred(in, out) is det, in, out) is det.
+
+my_map_par_future(_, [], []).
+my_map_par_future(M, [X | Xs], Ys) :-
+    FutY = future((func) = Y0 :- M(X, Y0)),
+    my_map_par_future(M, Xs, Ys0),
+    Y = wait(FutY),
+    Ys = [Y | Ys0].
+
 :- pred my_map_par_spawn(pred(X, Y), list(X), list(Y)).
 :- mode my_map_par_spawn(pred(in, out) is det, in, out) is cc_multi.
 

library/library.m

@@ -301,6 +301,7 @@
 mercury_std_library_module("thread").
 mercury_std_library_module("thread.barrier").
 mercury_std_library_module("thread.channel").
+mercury_std_library_module("thread.future").
 mercury_std_library_module("thread.mvar").
 mercury_std_library_module("thread.semaphore").
 mercury_std_library_module("tree234").