Changeset 4311

Timestamp:

06/13/08 04:04:50 (4 months ago)

Author:

pmoura

Message:

Updated the "mtbatch" example to include a benchmark test for competitive or-parallelism applied to state-space search (using the resources from the "searching" example). Improved the example documentation.

Location:

trunk

Files:

• examples/threads/mtbatch/loader.lgt (modified) (1 diff)
• examples/threads/mtbatch/mtbatch.lgt (modified) (4 diffs)
• examples/threads/mtbatch/NOTES.txt (modified) (1 diff)
• RELEASE_NOTES.txt (modified) (1 diff)

trunk/examples/threads/mtbatch/loader.lgt

@@ -10 +10 @@
     logtalk_load(fft(loader)),
     logtalk_load(integration(loader)),
+    logtalk_load(roots(loader), [reload(skip)]),
+    logtalk_load([
+        searching(state_space),
+        searching(heuristic_state_space),
+        searching(salt3),
+        searching(search_strategy),
+        searching(blind_search1),
+        searching(breadth_first1),
+        searching(depth_first1),
+        searching(heuristic_search1),
+        searching(best_first1),
+        searching(hill_climbing1)], [reload(skip)]),
     logtalk_load(mtbatch, [misspelt(silent)])
     )). 

trunk/examples/threads/mtbatch/mtbatch.lgt

@@ -8 +8 @@
         comment is 'Multi-threading benchmarks.',
         parameters is ['Prolog'- 'Prolog backend compiler. Supported compilers are SWI-Prolog (swi), YAP (yap), and XSB (xsb).']]).
+
+    :- threaded.
 
     :- uses(integer, [between/3]).
@@ -173 +175 @@
                     )), nl
             )), nl.
-
 
     % integration benchmarks:
@@ -236 +237 @@
             )), nl.
 
+    % state-space search benchmarks:
+    run(search, N) :-
+        write('State-space search benchmarks (average of '), write(N), write(' runs)'), nl,
+        loop::forto(Liters, 1, 14,
+            (   put_char('\t'), write(Liters)
+            )), nl,
+        write('DF'), put_char('\t'),
+        loop::forto(Liters, 1, 14,
+            (   catch(run(depth_first(Liters, 5, 9, 14), N, Average), Error, write_error) ->
+                (   var(Error) ->
+                    write_average(Average)
+                ;   true
+                )
+            )), nl,
+        write('HF'), put_char('\t'),
+        loop::forto(Liters, 1, 14,
+            (   catch(run(hill_climbing(Liters, 5, 9, 14), N, Average), Error, write_error) ->
+                (   var(Error) ->
+                    write_average(Average)
+                ;   true
+                )
+            )), nl,
+        write('BF'), put_char('\t'),
+        loop::forto(Liters, 1, 14,
+            (   catch(run(breadth_first(Liters, 5, 9, 14), N, Average), Error, write_error) ->
+                (   var(Error) ->
+                    write_average(Average)
+                ;   true
+                )
+            )), nl,
+        write('COP'), put_char('\t'),
+        loop::forto(Liters, 1, 14,
+            (   catch(run(competitive(Liters, 5, 9, 14), N, Average), Error, write_error) ->
+                (   var(Error) ->
+                    write_average(Average)
+                ;   true
+                )
+            )), nl.
+
     run(Id, N, Average) :-
         walltime_begin(Walltime1),
@@ -309 +349 @@
     do_benchmark(quadsplit(_, _, _, _, _), _).
 
+    do_benchmark(depth_first(Liters, Jug1, Jug2, MaxDepth), N) :-
+        Obj = salt(Liters, Jug1, Jug2),
+        Obj::initial_state(Initial),
+        repeat(N),
+            once(depth_first(MaxDepth)::solve(Obj, Initial, _)),
+        fail.
+    do_benchmark(depth_first(_, _, _, _), _).
+
+    do_benchmark(hill_climbing(Liters, Jug1, Jug2, MaxDepth), N) :-
+        Obj = salt(Liters, Jug1, Jug2),
+        Obj::initial_state(Initial),
+        repeat(N),
+            once(hill_climbing(MaxDepth)::solve(Obj, Initial, _, _)),
+        fail.
+    do_benchmark(hill_climbing(_, _, _, _), _).
+
+    do_benchmark(breadth_first(Liters, Jug1, Jug2, MaxDepth), N) :-
+        Obj = salt(Liters, Jug1, Jug2),
+        Obj::initial_state(Initial),
+        repeat(N),
+            once(breadth_first(MaxDepth)::solve(Obj, Initial, _)),
+        fail.
+    do_benchmark(breadth_first(_, _, _, _), _).
+
+    do_benchmark(competitive(Liters, Jug1, Jug2, MaxDepth), N) :-
+        Obj = salt(Liters, Jug1, Jug2),
+        Obj::initial_state(Initial),
+        repeat(N),
+            threaded((
+                    depth_first(MaxDepth)::solve(Obj, Initial, _)
+                ;   hill_climbing(MaxDepth)::solve(Obj, Initial, _, _)
+                ;   breadth_first(MaxDepth)::solve(Obj, Initial, _)
+            )),
+        fail.
+    do_benchmark(competitive(_, _, _, _), _).
+
     walltime_begin(Walltime) :-
         parameter(1, Prolog),

trunk/examples/threads/mtbatch/NOTES.txt

@@ -9 +9 @@
 To load this example and for sample queries, please see the SCRIPT file.
 
-This folder provides an object for running multi-threading benchmarks.
+This folder provides a parametric object for running multi-threading 
+benchmarks. The object parameter must be instantiated with an atom 
+representing the back-end Prolog compiler being used:
+
+    SWI-Prolog: swi
+    YAP:        yap
+    XSB:        xsb
+
+This is necessary due to the different built-in predicates used by each 
+Prolog compiler for timing statistics.
+
+For example, the following goal will run all benchmark tests (assuming 
+we're using SWI-Prolog as the back-end compiler):
+
+    | ?- mtbatch(swi)::run.
+
+You may also run just a single benchmark test a given number of times.
+For example:
+
+    | ?- mtbatch(swi)::run(primes, 10).
+
+The following tests are available:
+
+    primes
+    msort
+    qsort
+    fib
+    hanoi
+    tak
+    fft
+    integration
+    search

trunk/RELEASE_NOTES.txt

@@ -49 +49 @@
     taken into account when comparing states). Updated the "salt" example 
     to support heuristics.
+
+    Updated the "mtbatch" example to include a benchmark test for competitive 
+    or-parallelism applied to state-space search (using the resources from the
+    "searching" example). Improved the example documentation.
 
     Updated the syntax coloring support for the Vim text editor to properly