9fc2c47d53
git-svn-id: https://yap.svn.sf.net/svnroot/yap/trunk@1908 b08c6af1-5177-4d33-ba66-4b1c6b8b522a
241 lines
17 KiB
HTML
241 lines
17 KiB
HTML
<?xml version="1.0" encoding="utf-8"?>
|
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
|
|
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
|
|
|
|
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
|
|
|
|
<head>
|
|
<meta http-equiv="content-type" content="application/xml+xhtml; charset=utf-8" />
|
|
<title>Logtalk user manual: multi-threading programming</title>
|
|
<link rel="stylesheet" href="../screen.css" type="text/css" media="screen"/>
|
|
<link rel="stylesheet" href="../print.css" type="text/css" media="print"/>
|
|
</head>
|
|
|
|
<body>
|
|
|
|
<div class="top-left">Logtalk user manual</div>
|
|
<div class="top-right">Multi-threading programming</div>
|
|
<div class="bottom-left"><span class="page"/></div>
|
|
<div class="bottom-right"><span class="page"/></div>
|
|
<div class="navtop"><a href="../index.html">contents</a> > <a href="index.html">user manual</a></div>
|
|
|
|
<h1 id="threads_threads">Multi-threading programming</h1>
|
|
|
|
<p>
|
|
Logtalk provides <strong>experimental</strong> support for multi-threading programming on selected Prolog compilers. Logtalk makes use of the low-level Prolog built-in predicates that interface with POSIX threads (or a suitable emulation), providing a small set of high-level predicates and directives that allows programmers to easily take advantage of modern multi-processor and multi-core computers without worrying about the details of creating, synchronizing, or communicating with threads. Logtalk multi-threading programming integrates with object-oriented programming by enabling objects and categories to prove goals concurrently and to send both synchronous and asynchronous messages.
|
|
</p>
|
|
|
|
<h2 id="threads_enabling">Enabling multi-threading support</h2>
|
|
|
|
<p>
|
|
Multi-threading support may be disabled by default. It can be enabled on the Prolog configuration files of supported compilers by setting the read-only compiler flag <code>threads</code> to <code>on</code>.
|
|
</p>
|
|
|
|
<h2 id="threads_directive">Enabling objects to make multi-threading calls</h2>
|
|
|
|
<p>
|
|
The <a title="Consult reference manual" href="../refman/directives/threaded0.html"><code>threaded/0</code></a> object directive is used to enable an object to make multi-threading calls:
|
|
</p>
|
|
<pre>:- threaded.</pre>
|
|
<p>
|
|
This directive results in the automatic creation and set up an object message queue when the object is loaded or created at runtime. Object message queues are used for exchanging thread notifications and for storing concurrent goal solutions and replies to the <em>multi-threading calls</em> made within the object. The message queue for the pseudo-object <code>user</code> is automatically created when Logtalk is loaded (provided that multi-threading programming is supported and enabled for the chosen Prolog compiler).
|
|
</p>
|
|
|
|
<h2 id="threads_builtins">Multi-threading built-in predicates</h2>
|
|
|
|
<p>
|
|
Logtalk provides a small set of built-in predicates for multi-threading programming. For simple tasks where you simply want to prove a set of goals, each one in its own thread, Logtalk provides a <a title="Consult reference manual" href="../refman/builtins/threaded1.html"><code>threaded/1</code></a> built-in predicate. The remaining predicates allow for fine-grained control, including postponing retrieving of thread goal results at a later time, supporting non-deterministic thread goals, and make <em>one-way</em> asynchronous calls. Together, these predicates provide high-level support for multi-threading programming, covering most common use cases.
|
|
</p>
|
|
|
|
<h3 id="threads_threaded">Proving goals concurrently using threads</h3>
|
|
|
|
<p>
|
|
A conjunction of goals may be proved concurrently by calling the Logtalk built-in predicate <a title="Consult reference manual" href="../refman/builtins/threaded1.html"><code>threaded/1</code></a>. Each goal in the conjunction runs in its own thread. This is akin to <em>and-parallelism</em>. For example, assume that we want to find all the prime numbers in a given interval, <code>[N, M]</code>. We can split the interval in two parts and then span two threads to compute the primes numbers in each sub-interval:
|
|
</p>
|
|
<pre>prime_numbers(N, M, Primes) :-
|
|
M > N,
|
|
N1 is N + (M - N) // 2,
|
|
N2 is N1 + 1,
|
|
threaded((
|
|
prime_numbers(N2, M, [], Acc),
|
|
prime_numbers(N, N1, Acc, Primes)
|
|
)).
|
|
|
|
prime_numbers(N, M, Acc, Primes) :-
|
|
...
|
|
</pre>
|
|
<p>
|
|
The <code>threaded/1</code> call terminates when the two implicit threads terminate. In a computer with two or more processors (or with a processor with two or more cores) the code above can be expected to provide better computation times when compared with single-threaded code for sufficiently large intervals.
|
|
</p>
|
|
<p>
|
|
The <code>threaded/1</code> built-in predicate is most useful for lengthy, independent deterministic computations where the computational costs of each goal outweigh the overhead of the implicit thread creation and management.
|
|
</p>
|
|
|
|
<h3 id="threads_call">Proving goals asynchronously using threads</h3>
|
|
|
|
<p>
|
|
A goal may be proved asynchronously using a new thread by calling the Logtalk built-in predicate <a title="Consult reference manual" href="../refman/builtins/threaded_call1.html"><code>threaded_call/1</code></a>. Calls to this predicate are always true and return immediately (assuming a callable argument). The term representing the goal is copied, not shared with the thread.
|
|
</p>
|
|
<p>
|
|
The results of proving a goal asynchronously in a new thread may be later retrieved by calling the Logtalk built-in predicate <a title="Consult reference manual" href="../refman/builtins/threaded_exit1.html"><code>threaded_exit/1</code></a> within the same object where the call to the <code>threaded_call/1</code> predicate was made. The <code>threaded_exit/1</code> calls block execution until the results of the <code>threaded_call/1</code> calls are sent back to the object message queue.
|
|
</p>
|
|
<p>
|
|
The <code>threaded_exit/1</code> predicate allow us to retrieve alternative solutions through backtracking (if you want to commit to the first solution, you may use the <a title="Consult reference manual" href="../refman/builtins/threaded_once1.html"><code>threaded_once/1</code></a> predicate instead of the <code>threaded_call/1</code> predicate). For example, assuming a <code>lists</code> object implementing the usual <code>member/2</code> predicate, we could write:
|
|
</p>
|
|
<pre>| ?- threaded_call(lists::member(X, [1,2,3])).
|
|
|
|
X = _G189
|
|
yes
|
|
|
|
| ?- threaded_exit(lists::member(X, [1,2,3])).
|
|
|
|
X = 1 ;
|
|
X = 2 ;
|
|
X = 3 ;
|
|
no
|
|
</pre>
|
|
<p>
|
|
In this case, the <code>threaded_call/1</code> and the <code>threaded_exit/1</code> calls are made within the pseudo-object <em>user</em>. The implicit thread running the <code>lists::member/2</code> goal suspends itself after providing a solution, waiting for a request to an alternative solution; the thread is automatically terminated when the runtime engine detects that backtracking to the <code>threaded_exit/1</code> call is no longer possible.
|
|
</p>
|
|
<p>
|
|
Calls to the <code>threaded_exit/1</code> predicate block the caller until the object message queue receives the reply to the asynchronous call. The predicate <a title="Consult reference manual" href="../refman/builtins/threaded_peek1.html"><code>threaded_peek/1</code></a> may be used to check if a reply is already available without removing it from the thread queue. The <code>threaded_peek/1</code> predicate call succeeds or fails immediately without blocking the caller. However, keep in mind that repeated use of this predicate is equivalent to polling a message queue, which may severely hurt performance.
|
|
</p>
|
|
<p>
|
|
Be careful when using the <code>threaded_exit/1</code> predicate inside failure-driven loops. When all the solutions have been found (and the thread generating them is therefore terminated), re-calling the predicate will generate an exception. Note that failing instead of throwing an exception is not an acceptable solution as it could be misinterpreted as a failure of the <code>threaded_exit/1</code> argument.
|
|
</p>
|
|
<p>
|
|
The example on the previous section with prime numbers could be rewritten using the <code>threaded_call/1</code> and <code>threaded_exit/1</code> predicates:
|
|
</p>
|
|
<pre>prime_numbers(N, M, Primes) :-
|
|
M > N,
|
|
N1 is N + (M - N) // 2,
|
|
N2 is N1 + 1,
|
|
threaded_call(prime_numbers(N2, M, [], Acc)),
|
|
threaded_call(prime_numbers(N, N1, Acc, Primes)),
|
|
threaded_exit(prime_numbers(N2, M, [], Acc)),
|
|
threaded_exit(prime_numbers(N, N1, Acc, Primes)).
|
|
|
|
prime_numbers(N, M, Acc, Primes) :-
|
|
...
|
|
</pre>
|
|
|
|
<h2 id="threads_ignore">One-way asynchronous calls</h2>
|
|
|
|
<p>
|
|
Sometimes we want to prove a goal in a new thread without caring about the results. This may be accomplished by using the built-in predicate <a title="Consult reference manual" href="../refman/builtins/threaded_ignore1.html"><code>threaded_ignore/1</code></a>. For example, assume that we are developing a multi-agent application where an agent may send an "happy birthday" message to another agent. We could write:
|
|
</p>
|
|
<pre>threaded_ignore(agent::happy_birthday), ...
|
|
</pre>
|
|
<p>
|
|
The call succeeds with no reply of the goal success, failure, or even exception ever being sent back to the object making the call. Note that this predicate implicitly implies a deterministic call of its argument.
|
|
</p>
|
|
|
|
|
|
<h2 id="threads_competing">Competing goals</h2>
|
|
|
|
<p>
|
|
The built-in predicate <a title="Consult reference manual" href="../refman/builtins/threaded_race1.html"><code>threaded_race/1</code></a> allows a disjunction of goals to be interpreted as a set of <em>competing</em> goals, each one running on its own thread. The first thread to terminate successfully leads to the termination of the other threads. This is useful when we have several methods to compute something, without knowing a priori which method will be faster. For example, assume that we have defined a predicate <code>try_method/2</code> that calls a chosen method, returning its result. We may then write:
|
|
</p>
|
|
<pre>method(Result) :-
|
|
...,
|
|
threaded_race(
|
|
( try_method(method1, Result)
|
|
; try_method(method2, Result)
|
|
; ...
|
|
)),
|
|
threaded_exit(try_method(Method, Result)),
|
|
...
|
|
</pre>
|
|
<p>
|
|
The <code>threaded_exit/1</code> call will return both the identifier of the fastest method and its result. Note that, when setting up competing goals such as in the example above, we must ensure that the argument of the <code>threaded_exit/1</code> call unifies with each individual goal in the disjunction used as argument on the <code>threaded_race/1</code> call. This ensures that the <code>threaded_exit/1</code> call will return the results of the first method to complete, no matter which one.
|
|
</p>
|
|
|
|
<h2 id="threads_synchronized_predicates">Asynchronous calls and synchronized predicates</h2>
|
|
|
|
<p>
|
|
Proving a goal asynchronously using a new thread may lead to problems when the goal implies side-effects such as input/output operations or modifications to an object database. For example, if a new thread is started with the same goal before the first one finished its job, we may end up with mixed output, a corrupted database, or unexpected goal failures. In order to solve this problem, predicates (and grammar rule non-terminals) with side-effects can be declared as <em>synchronized</em> by using the <a title="Consult reference manual" href="../refman/directives/synchronized1.html"><code>synchronized/1</code></a> predicate directive. Proving a query to a synchronized predicate (or synchronized non-terminal) is internally protected by a mutex, thus allowing for easy thread synchronization. For example:
|
|
</p>
|
|
<pre>:- synchronized(db_update/1). % ensure thread synchronization
|
|
|
|
db_update(Update) :- % predicate with side-effects
|
|
...
|
|
</pre>
|
|
<p>
|
|
A second example: assume an object defining two predicates for writing, respectively, even and odd numbers in a given interval to the standard output. Given a large interval, a goal such as:
|
|
</p>
|
|
<pre>| ?- threaded_call(obj::odd_numbers(1,1000)), threaded_call(obj::even_numbers(1,1000)).
|
|
|
|
1 3 2 4 6 8 5 7 10 ...
|
|
...
|
|
</pre>
|
|
<p>
|
|
will most likely result in a mixed up output. By declaring the <code>odd_numbers/2</code> and <code>even_numbers/2</code> predicates synchronized:
|
|
</p>
|
|
<pre>:- synchronized([
|
|
odd_numbers/2,
|
|
even_numbers/2]).
|
|
</pre>
|
|
<p>
|
|
one goal will only start after the other one finished:
|
|
</p>
|
|
<pre>| ?- threaded_ignore(obj::odd_numbers(1,1000)), threaded_ignore(obj::even_numbers(1,1000)).
|
|
|
|
1 3 5 7 9 11 ...
|
|
...
|
|
2 4 6 8 10 12 ...
|
|
...
|
|
</pre>
|
|
<p>
|
|
Note that, in a more realistic scenario, the two <code>threaded_ignore/1</code> calls would be made concurrently from different objects. Using the same synchronized directive for a set of predicates imply that they all use the same mutex, as required for this example.
|
|
</p>
|
|
|
|
<p>
|
|
The <code>synchronized/1</code> directive must precede any local calls to the synchronized predicate (or synchronized non-terminal) in order to ensure proper compilation. In addition, as each Logtalk entity is independently compiled, this directive must be included in every object or category that contains a definition for the described predicate, even if the predicate declaration is inherited from another entity, in order to ensure proper compilation.
|
|
</p>
|
|
<p>
|
|
Logtalk supports both deterministic and non-deterministic synchronized predicates (and synchronized non-terminals). However, whenever possible, synchronized predicates should be coded as deterministic predicates in order to avoid deadlocks. In those cases where the predicate (or grammar rule) is defined in the same object (or category) where the predicate is declared synchronized, Logtalk takes advantage of any existing <a title="Consult reference manual" href="../refman/directives/mode2.html"><code>mode/2</code></a> directives in order to generate the most appropriated mutex handling code. When no <code>mode/2</code> predicate directives are presented, Logtalk assumes a deterministic predicate when generating the mutex handling code.
|
|
</p>
|
|
<p>
|
|
We may declare all predicates of an object (or a category) as synchronized by using the entity directive <a title="Consult reference manual" href="../refman/directives/synchronized0.html"><code>synchronized/0</code></a>. In this case, the <code>synchronized/1</code> predicate directive is not necessary and should not be used.
|
|
</p>
|
|
<p>
|
|
Synchronized predicates may be used as wrappers to messages sent to objects that are not multi-threading aware. For example, assume a <code>random</code> object defining a <code>random/1</code> predicate that generates random numbers, using side-effects on its implementation (e.g. for storing the generator seed). We can specify and define e.g. a <code>sync_random/1</code> predicate as follows:
|
|
</p>
|
|
<pre>
|
|
:- synchronized(sync_random/1).
|
|
|
|
sync_random(Random) :-
|
|
random::random(Random).
|
|
</pre>
|
|
<p>
|
|
and then always use the <code>sync_random/1</code> predicate instead of the predicate <code>random/1</code> from multi-threaded code.
|
|
</p>
|
|
<p>
|
|
The synchronization entity and predicate directives may be used when defining objects that may be reused in both single-threaded and multi-threaded Logtalk applications. The directives are simply ignored (i.e. the synchronized predicates are interpreted as normal predicates) when the objects are used in a single-threaded application.
|
|
</p>
|
|
|
|
<h2 id="threads_notifications">Synchronizing threads through notifications</h2>
|
|
|
|
<p>
|
|
Declaring a set of predicates as synchronized can only ensure that they are not executed at the same time by different threads. Sometimes we need to suspend a thread not on a synchronization lock but on some condition that must hold true for a thread goal to proceed. I.e. we want a thread goal to be suspended until a condition becomes true instead of simply failing. The built-in predicate <a title="Consult reference manual" href="../refman/builtins/threaded_wait1.html"><code>threaded_wait/1</code></a> allows us to suspend a predicate execution (running in its own thread) until a notification is received. Notifications are posted using the built-in predicate
|
|
<a title="Consult reference manual" href="../refman/builtins/threaded_notify1.html"><code>threaded_notify/1</code></a>. A notification is a Prolog term that a programmer chooses to represent some condition becoming true. Any Prolog term can be used as a notification argument for these predicates. Related calls to the <code>threaded_wait/1</code> and <code>threaded_notify/1</code> must be made within the same object, <em>this</em>, as the object message queue is used internally for posting and retrieving notifications.
|
|
</p>
|
|
<p>
|
|
Each notification posted by a call to the <code>threaded_notify/1</code> predicate is consumed by a single <code>threaded_wait/1</code> predicate call (i.e. these predicates implement a peer-to-peer mechanism). Care should be taken to avoid deadlocks when two (or more) threads both wait and post notifications to each other.
|
|
</p>
|
|
|
|
<div class="footer">
|
|
<div class="copyright">
|
|
<span>Copyright © <a href="mailto:pmoura@logtalk.org">Paulo Moura</a> — <a href="http://logtalk.org">Logtalk.org</a></span><br/>
|
|
<span>Last updated on: June 19, 2007</span>
|
|
</div>
|
|
<div class="navbottom">
|
|
<span><a href="events.html">previous</a> | <a href="../glossary.html">glossary</a> | <a href="errors.html">next</a></span><br/>
|
|
<span><a href="http://validator.w3.org/check/referer">XHTML</a> + <a href="http://jigsaw.w3.org/css-validator/check/referer">CSS</a></span>
|
|
</div>
|
|
</div>
|
|
|
|
</body>
|
|
|
|
</html>
|