Changeset 4455 for trunk/examples

Timestamp:

08/30/08 06:47:37 (4 months ago)

Author:

pmoura

Message:

Updated the "mtbatch" example to detect unexpected failures when running the multi-threading integration benchmarks.

Update the "integration2d" multi-threading example to make the recursive and the split/spawn/collect methods equivalent.

Location:

trunk/examples/threads

Files:

• integration2d/integration2d.lgt (modified) (3 diffs)
• mtbatch/mtbatch.lgt (modified) (7 diffs)

trunk/examples/threads/integration2d/integration2d.lgt

@@ -121 +121 @@
 
     :- info([
-        version is 1.0,
+        version is 1.1,
         author is 'Paul Crocker',
-        date is 2008/03/17,
+        date is 2008/08/30,
         comment is 'Multi-threading implementation of Recursive Gaussian Quadrature Methods for Numerical Integration for functions of two real variables.',
         parameters is ['Threads'- 'Number of threads to use.']]).
@@ -136 +136 @@
             start(Function, A, B, C, D, NP, Epsilon, Integral)
         ;   % Threads > 1
+            Threads2 is round(sqrt(Threads)),
             Epsilon2 is Epsilon/Threads,
-            split(A, B, Threads, Intervals),
-            spawn(Intervals, Function, C, D, NP, Epsilon2, Goals),
+            split(A, B, Threads2, ABIntervals),
+            split(C, D, Threads2, CDIntervals),
+            spawn(ABIntervals, CDIntervals, Function, NP, Epsilon2, [], Goals),
             collect(Goals, 0.0, Integral)
         ).
@@ -155 +157 @@
 
     % initiate the thread calls
-    spawn([], _, _, _,_, _, []).
-    spawn([Left-Right| Intervals], Function, C, D, NP, Epsilon, [start(Function,Left,Right,C,D,NP,Epsilon,SubVolume)| Goals]) :-
-        threaded_once(start(Function,Left,Right,C,D,NP,Epsilon,SubVolume)),
-        spawn(Intervals, Function, C,D, NP, Epsilon, Goals).
+    spawn([], _, _, _, _, Goals, Goals).
+    spawn([Left-Right| ABIntervals], CDIntervals, Function, NP, Epsilon, Acc, Goals) :-
+        spawn(CDIntervals, Left, Right, Function, NP, Epsilon, Acc, Acc2),
+        spawn(ABIntervals, CDIntervals, Function, NP, Epsilon, Acc2, Goals).
+
+    spawn([], _, _, _, _, _, Goals, Goals).
+    spawn([Bottom-Top| CDIntervals], Left, Right, Function, NP, Epsilon, Acc, Goals) :-
+        threaded_once(start(Function,Left,Right,Bottom,Top,NP,Epsilon,SubVolume)),
+        spawn(CDIntervals, Left, Right, Function, NP, Epsilon, [start(Function,Left,Right,Bottom,Top,NP,Epsilon,SubVolume)| Acc], Goals).
 
     % wait for the threads to finish and then we will collect the results summing as we go
     collect([], Integral, Integral).
-    collect([start(Function,Left,Right,C,D,NP,Epsilon,SubVolume)| Goals], Acc, Integral) :-
-        threaded_exit(start(Function,Left,Right,C,D,NP,Epsilon,SubVolume)),     
+    collect([start(Function,Left,Right,Bottom,Top,NP,Epsilon,SubVolume)| Goals], Acc, Integral) :-
+        threaded_exit(start(Function,Left,Right,Bottom,Top,NP,Epsilon,SubVolume)),      
         Acc2 is Acc + SubVolume,
         collect(Goals, Acc2, Integral).

trunk/examples/threads/mtbatch/mtbatch.lgt

@@ -3 +3 @@
 
     :- info([
-        version is 1.1,
+        version is 1.2,
         author is 'Paulo Moura',
-        date is 2008/06/14,
+        date is 2008/08/30,
         comment is 'Multi-threading benchmarks.',
         parameters is ['Prolog'- 'Prolog backend compiler. Supported compilers are SWI-Prolog (swi), YAP (yap), and XSB (xsb).']]).
@@ -272 +272 @@
         write('Numerical integration of functions of two variables (average of '), write(N), write(' runs)'), nl,
         write('using a split/spawn/collect quadrature method with '), write(NP), write(' points'), nl,
-        loop::forto(T, 0, 4,
-            (   Threads is truncate(2**T),
+        loop::forto(T, 1, 4,
+            (   Threads is T*T,
                 put_char('\t'), write(Threads)
             )), nl,
@@ -288 +288 @@
             ),
             (   write(Function),
-                loop::forto(T, 0, 4,
-                    (   Threads is truncate(2**T),
+                loop::forto(T, 1, 4,
+                    (   Threads is T*T,
                         catch(run(quadsplit2d(Threads, Function, A, B, C, D, NP, Epsilon), N, Average), Error, write_error) ->
                         (   var(Error) ->
@@ -408 +408 @@
     do_benchmark(quadrec(Threads, Function, Inf, Sup, NP, Epsilon), N) :-
         repeat(N),
-            quadrec(Threads)::integrate(Function, Inf, Sup, NP, Epsilon, _),
+            (   quadrec(Threads)::integrate(Function, Inf, Sup, NP, Epsilon, _) ->
+                true
+            ;   throw(error(failure))
+            ),
         fail.
     do_benchmark(quadrec(_, _, _, _, _, _), _).
@@ -414 +417 @@
     do_benchmark(quadsplit(Threads, Function, Inf, Sup, NP, Epsilon), N) :-
         repeat(N),
-            quadsplit(Threads)::integrate(Function, Inf, Sup, NP, Epsilon, _),
+            (   quadsplit(Threads)::integrate(Function, Inf, Sup, NP, Epsilon, _) ->
+                true
+            ;   throw(error(failure))
+            ),
         fail.
     do_benchmark(quadsplit(_, _, _, _, _, _), _).
@@ -420 +426 @@
     do_benchmark(quadrec2d(Threads, Function, A, B, C, D, NP, Epsilon), N) :-
         repeat(N),
-            quadrec2d(Threads)::integrate(Function, A, B, C, D, NP, Epsilon, _),
+            (   quadrec2d(Threads)::integrate(Function, A, B, C, D, NP, Epsilon, _) ->
+                true
+            ;   throw(error(failure))
+            ),
         fail.
     do_benchmark(quadrec2d(_, _, _, _, _, _, _, _), _).
@@ -426 +435 @@
     do_benchmark(quadsplit2d(Threads, Function, A, B, C, D, NP, Epsilon), N) :-
         repeat(N),
-            quadsplit2d(Threads)::integrate(Function,A, B, C, D, NP, Epsilon, _),
+            (   quadsplit2d(Threads)::integrate(Function,A, B, C, D, NP, Epsilon, _) ->
+                true
+            ;   throw(error(failure))
+            ),
         fail.
     do_benchmark(quadsplit2d(_, _, _, _, _, _, _, _), _).