The library(unix) library provides the commonly used Unix primitives to deal with process management. These primitives are useful for many tasks, including server management, parallel computation, exploiting and controlling other processes, etc.
The predicates in this library are modelled closely after their native Unix counterparts.
- fork(-Pid) is det
- Clone the current process into two branches. In the child, Pid
is unified to child. In the original process, Pid is unified to
the process identifier of the created child. Both parent and
child are fully functional Prolog processes running the same
program. The processes share open I/O streams that refer to Unix
native streams, such as files, sockets and pipes. Data is not
shared, though on most Unix systems data is initially shared and
duplicated only if one of the programs attempts to modify the
fork()is the only way to create new processes and fork/1 is a simple direct interface to it.
- fork_exec(+Command) is det
- Fork (as fork/1) and exec (using exec/1) the child immediately.
This behaves as the code below, but bypasses the check for the
existence of other threads because this is a safe scenario.
fork_exec(Command) :- ( fork(child) -> exec(Command) ; true ).
- Replace the running program by starting Command. Command is a
callable term. The functor is the command and the arguments
provide the command-line arguments for the command. Each
command-line argument must be atomic and is converted to a
string before passed to the Unix call
execvp(). Here are some examples:
exec()is the only way to start an executable file executing. It is commonly used together with fork/1. For example to start netscape on an URL in the background, do:
run_netscape(URL) :- ( fork(child), exec(netscape(URL)) ; true ).
Using this code, netscape remains part of the process-group of the invoking Prolog process and Prolog does not wait for netscape to terminate. The predicate wait/2 allows waiting for a child, while detach_IO/0 disconnects the child as a deamon process.
- wait(?Pid, -Status) is det
- Wait for a child to change status. Then report the child that
changed status as well as the reason. If Pid is bound on entry
then the status of the specified child is reported. If not, then
the status of any child is reported. Status is unified with
exited(ExitCode)if the child with pid Pid was terminated by calling
exit()(Prolog halt/1). ExitCode is the return status. Status is unified with
signaled(Signal)if the child died due to a software interrupt (see kill/2). Signal contains the signal number. Finally, if the process suspended execution due to a signal, Status is unified with
- kill(+Pid, +Signal) is det
- Deliver a software interrupt to the process with identifier Pid
using software-interrupt number Signal. See also on_signal/2.
Signals can be specified as an integer or signal name, where
signal names are derived from the C constant by dropping the
SIGprefix and mapping to lowercase. E.g.
intis the same as
SIGINTin C. The meaning of the signal numbers can be found in the Unix manual.
- pipe(-InSream, -OutStream) is det
- Create a communication-pipe. This is normally used to make a
child communicate to its parent. After pipe/2, the process is
cloned and, depending on the desired direction, both processes
close the end of the pipe they do not use. Then they use the
remaining stream to communicate. Here is a simple example:
:- use_module(library(unix)). fork_demo(Result) :- pipe(Read, Write), fork(Pid), ( Pid == child -> close(Read), format(Write, '~q.~n', [hello(world)]), flush_output(Write), halt ; close(Write), read(Read, Result), close(Read) ).
- dup(+FromStream, +ToStream) is det
- Interface to Unix
dup2(), copying the underlying filedescriptor and thus making both streams point to the same underlying object. This is normally used together with fork/1 and pipe/2 to talk to an external program that is designed to communicate using standard I/O.
Both FromStream and ToStream either refer to a Prolog stream or an integer descriptor number to refer directly to OS descriptors. See also
demo/pipe.plin the source-distribution of this package.
- detach_IO(+Stream) is det
- This predicate is intended to create Unix deamon processes. It
performs two actions.
- The I/O streams
user_errorare closed if they are connected to a terminal (see
ttyproperty in stream_property/2). Input streams are rebound to a dummy stream that returns EOF. Output streams are reboud to forward their output to Stream.
- The process is detached from the current process-group and
its controlling terminal. This is achieved using
setsid()if provided or using
To ignore all output, it may be rebound to a null stream. For example:
..., open_null_stream(Out), detach_IO(Out).
The detach_IO/1 should be called only once per process. Subsequent calls silently succeed without any side effects.
- The I/O streams
- detach_IO is det
- Detach I/O similar to detach_IO/1. The output streams are bound
to a file
/tmp/pl-out.<pid>. Output is line buffered (see set_stream/2).
- prctl(+Option) is det
- Access to Linux process control operations. Defines values for
- Control whether the process is allowed to dump core. This right is dropped under several uid and gid conditions.
- Get the value of the dumpable flag.
- sysconf(+Conf) is semidet
- Access system configuration. See
sysconf(1)for details. Conf is a term Config(Value), where Value is always an integer. Config is the
sysconf()name after removing =_SC_= and conversion to lowercase. Currently support the following configuration info:
nprocessors_onln. Note that not all values may be supported on all operating systems.
The following predicates are exported, but not or incorrectly documented.