/usr/share/doc/swi-prolog-doc/Manual/thutil.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">

<HTML>
<HEAD>
<TITLE>SWI-Prolog 5.6.59 Reference Manual: Section 8.5</TITLE><LINK REL=home HREF="index.html">
<LINK REL=contents HREF="Contents.html">
<LINK REL=index HREF="DocIndex.html">
<LINK REL=previous HREF="threadsync.html">
<LINK REL=next HREF="mtunbound.html">
<STYLE type="text/css">
/* Style sheet for SWI-Prolog latex2html
*/

dd.defbody
{ margin-bottom: 1em;
}

dt.pubdef
{ background-color: #c5e1ff;
}

pre.code
{ margin-left: 1.5em;
margin-right: 1.5em;
border: 1px dotted;
padding-top: 5px;
padding-left: 5px;
padding-bottom: 5px;
background-color: #f8f8f8;
}

div.navigate
{ text-align: center;
background-color: #f0f0f0;
border: 1px dotted;
padding: 5px;
}

div.title
{ text-align: center;
padding-bottom: 1em;
font-size: 200%;
font-weight: bold;
}

div.author
{ text-align: center;
font-style: italic;
}

div.abstract
{ margin-top: 2em;
background-color: #f0f0f0;
border: 1px dotted;
padding: 5px;
margin-left: 10%; margin-right:10%;
}

div.abstract-title
{ text-align: center;
padding: 5px;
font-size: 120%;
font-weight: bold;
}

div.toc-h1
{ font-size: 200%;
font-weight: bold;
}

div.toc-h2
{ font-size: 120%;
font-weight: bold;
margin-left: 2em;
}

div.toc-h3
{ font-size: 100%;
font-weight: bold;
margin-left: 4em;
}

div.toc-h4
{ font-size: 100%;
margin-left: 6em;
}

span.sec-nr
{ 
}

span.sec-title
{ 
}

span.pred-ext
{ font-weight: bold;
}

span.pred-tag
{ float: right;
font-size: 80%;
font-style: italic;
color: #202020;
}

/* Footnotes */

sup.fn { color: blue; text-decoration: underline; }
span.fn-text { display: none; }
sup.fn span {display: none;}
sup:hover span 
{ display: block !important;
position: absolute; top: auto; left: auto; width: 80%;
color: #000; background: white;
border: 2px solid;
padding: 5px; margin: 10px; z-index: 100;
font-size: smaller;
}
</STYLE>
</HEAD>
<BODY BGCOLOR="white">
<DIV class="navigate"><A class="nav" href="index.html"><IMG SRC="home.gif" BORDER=0 ALT="Home"></A>
<A class="nav" href="Contents.html"><IMG SRC="index.gif" BORDER=0 ALT="Contents"></A>
<A class="nav" href="DocIndex.html"><IMG SRC="yellow_pages.gif" BORDER=0 ALT="Index"></A>
<A class="nav" href="threadsync.html"><IMG SRC="prev.gif" BORDER=0 ALT="Previous"></A>
<A class="nav" href="mtunbound.html"><IMG SRC="next.gif" BORDER=0 ALT="Next"></A>
</DIV>

<H2><A NAME="sec:8.5"><SPAN class="sec-nr">8.5</SPAN> <SPAN class="sec-title">Thread-support 
library(threadutil)</SPAN></A></H2>

<A NAME="sec:thutil"></A>

<P>This library defines a couple of useful predicates for demonstrating 
and debugging multi-threaded applications. This library is certainly not 
complete.

<DL>
<DT class="pubdef"><A NAME="threads/0"><STRONG>threads</STRONG></A></DT>
<DD class="defbody">
Lists all current threads and their status.</DD>
<DT class="pubdef"><A NAME="join_threads/0"><STRONG>join_threads</STRONG></A></DT>
<DD class="defbody">
Join all terminated threads. For normal applications, dealing with 
terminated threads must be part of the application logic, either 
detaching the thread before termination or making sure it will be 
joined. The predicate <A NAME="idx:jointhreads0:1330"></A><A class="pred" href="thutil.html#join_threads/0">join_threads/0</A> 
is intended for interactive sessions to reclaim resources from threads 
that died unexpectedly during development.</DD>
<DT class="pubdef"><A NAME="interactor/0"><STRONG>interactor</STRONG></A></DT>
<DD class="defbody">
Create a new console and run the Prolog top-level in this new console. 
See also <A NAME="idx:attachconsole0:1331"></A><A class="pred" href="thutil.html#attach_console/0">attach_console/0</A>. 
In the Windows version a new interactor can also be created from the <B>Run/New 
thread</B> menu.
</DD>
</DL>

<H3><A NAME="sec:8.5.1"><SPAN class="sec-nr">8.5.1</SPAN> <SPAN class="sec-title">Debugging 
threads</SPAN></A></H3>

<A NAME="sec:threaddebug"></A>

<P>Support for debugging threads is still very limited. Debug and trace 
mode are flags that are local to each thread. Individual threads can be 
debugged either using the graphical debugger described in
<A class="sec" href="guitracer.html">section 3.5</A> (see <A NAME="idx:tspy1:1332"></A><A class="pred" href="thutil.html#tspy/1">tspy/1</A> 
and friends) or by attaching a console to the thread and running the 
traditional command-line debugger (see
<A NAME="idx:attachconsole0:1333"></A><A class="pred" href="thutil.html#attach_console/0">attach_console/0</A>). 
When using the graphical debugger, the debugger must be <EM>loaded</EM> 
from the main thread (for example using guitracer) before <A NAME="idx:gtrace0:1334"></A><A class="pred" href="guitracer.html#gtrace/0">gtrace/0</A> 
can be called from a thread.

<DL>
<DT class="pubdef"><A NAME="attach_console/0"><STRONG>attach_console</STRONG></A></DT>
<DD class="defbody">
If the current thread has no console attached yet, attach one and 
redirect the user streams (input, output, and error) to the new console 
window. On Unix systems the console is an <B>xterm</B> application. On 
Windows systems this requires the GUI version <B>plwin.exe</B> rather 
than the console based <B>plcon.exe</B>.

<P>This predicate has a couple of useful applications. One is to 
separate (debugging) I/O of different threads. Another is to start 
debugging a thread that is running in the background. If thread 10 is 
running, the following sequence starts the tracer on this thread:

<PRE class="code">
?- thread_signal(10, (attach_console, trace)).
</PRE>

</DD>
<DT class="pubdef"><A NAME="tdebug/1"><STRONG>tdebug</STRONG>(<VAR>+ThreadId</VAR>)</A></DT>
<DD class="defbody">
Prepare <VAR>ThreadId</VAR> for debugging using the graphical tracer. 
This implies installing the tracer hooks in the thread and switching the 
thread to debug-mode using <A NAME="idx:debug0:1335"></A><A class="pred" href="debugger.html#debug/0">debug/0</A>. 
The call is injected into the thread using <A NAME="idx:threadsignal2:1336"></A><A class="pred" href="threadcom.html#thread_signal/2">thread_signal/2</A>. 
We refer to the documentation of this predicate for asynchronous 
interaction with threads. New threads created inherit their debug-mode 
from the thread that created them.</DD>
<DT class="pubdef"><A NAME="tdebug/0"><STRONG>tdebug</STRONG></A></DT>
<DD class="defbody">
Call <A NAME="idx:tdebug1:1337"></A><A class="pred" href="thutil.html#tdebug/1">tdebug/1</A> 
in all running threads.</DD>
<DT class="pubdef"><A NAME="tnodebug/1"><STRONG>tnodebug</STRONG>(<VAR>+ThreadId</VAR>)</A></DT>
<DD class="defbody">
Disable debugging thread <VAR>ThreadId</VAR>.</DD>
<DT class="pubdef"><A NAME="tnodebug/0"><STRONG>tnodebug</STRONG></A></DT>
<DD class="defbody">
Disable debugging in all threads.</DD>
<DT class="pubdef"><A NAME="tspy/2"><STRONG>tspy</STRONG>(<VAR>:Spec, 
+ThreadId</VAR>)</A></DT>
<DD class="defbody">
Set a spy-point as <A NAME="idx:spy1:1338"></A><A class="pred" href="debugger.html#spy/1">spy/1</A> 
and enable the thread for debugging using
<A NAME="idx:tdebug1:1339"></A><A class="pred" href="thutil.html#tdebug/1">tdebug/1</A>. 
Note that a spy-point is a global flag on a predicate that is visible 
from all threads. Spy points are honoured in all threads that are in 
debug-mode and ignored in threads that are in nodebug mode.</DD>
<DT class="pubdef"><A NAME="tspy/1"><STRONG>tspy</STRONG>(<VAR>:Spec</VAR>)</A></DT>
<DD class="defbody">
Set a spy-point as <A NAME="idx:spy1:1340"></A><A class="pred" href="debugger.html#spy/1">spy/1</A> 
and enable debugging in all threads using
<A NAME="idx:tdebug0:1341"></A><A class="pred" href="thutil.html#tdebug/0">tdebug/0</A>. 
Note that removing spy-points can be done using <A NAME="idx:nospy1:1342"></A><A class="pred" href="debugger.html#nospy/1">nospy/1</A>. 
Disabling spy-points in a specific thread is achieved by <A NAME="idx:tnodebug1:1343"></A><A class="pred" href="thutil.html#tnodebug/1">tnodebug/1</A>.
</DD>
</DL>

<H3><A NAME="sec:8.5.2"><SPAN class="sec-nr">8.5.2</SPAN> <SPAN class="sec-title">Profiling 
threads</SPAN></A></H3>

<A NAME="sec:tprofile"></A>

<P>In the current implementation, at most one thread can be profiled at 
any moment. Any thread can call <A NAME="idx:profile1:1344"></A><A class="pred" href="profile.html#profile/1">profile/1</A> 
to profile the execution of some part of its code. The predicate <A NAME="idx:tprofile1:1345"></A><A class="pred" href="thutil.html#tprofile/1">tprofile/1</A> 
allows for profiling the execution of another thread until the user 
stops collecting profile data.

<DL>
<DT class="pubdef"><A NAME="tprofile/1"><STRONG>tprofile</STRONG>(<VAR>+ThreadId</VAR>)</A></DT>
<DD class="defbody">
Start collecting profile data in <VAR>ThreadId</VAR> and ask the user to 
hit &lt;return&gt; to stop the profiler. See <A class="sec" href="profile.html">section 
4.40</A> for details on the execution profiler.
</DD>
</DL>

<P></BODY></HTML>
swi-prolog-doc 5.6.59-1 / usr / share / doc / swi-prolog-doc / Manual / thutil.html
