Integrate perlio:
[p5sagit/p5-mst-13.2.git] / pod / perlfork.pod
CommitLineData
7766f137 1=head1 NAME
2
c7fa416b 3perlfork - Perl's fork() emulation (EXPERIMENTAL, subject to change)
7766f137 4
5=head1 SYNOPSIS
6
c7fa416b 7 WARNING: As of the 5.6.1 release, the fork() emulation continues
8 to be an experimental feature. Use in production applications is
9 not recommended. See the "BUGS" and "CAVEATS AND LIMITATIONS"
10 sections below.
11
7766f137 12Perl provides a fork() keyword that corresponds to the Unix system call
13of the same name. On most Unix-like platforms where the fork() system
14call is available, Perl's fork() simply calls it.
15
16On some platforms such as Windows where the fork() system call is not
17available, Perl can be built to emulate fork() at the interpreter level.
18While the emulation is designed to be as compatible as possible with the
106325ad 19real fork() at the level of the Perl program, there are certain
7766f137 20important differences that stem from the fact that all the pseudo child
21"processes" created this way live in the same real process as far as the
22operating system is concerned.
23
24This document provides a general overview of the capabilities and
25limitations of the fork() emulation. Note that the issues discussed here
26are not applicable to platforms where a real fork() is available and Perl
27has been configured to use it.
28
29=head1 DESCRIPTION
30
31The fork() emulation is implemented at the level of the Perl interpreter.
32What this means in general is that running fork() will actually clone the
33running interpreter and all its state, and run the cloned interpreter in
34a separate thread, beginning execution in the new thread just after the
35point where the fork() was called in the parent. We will refer to the
36thread that implements this child "process" as the pseudo-process.
37
38To the Perl program that called fork(), all this is designed to be
39transparent. The parent returns from the fork() with a pseudo-process
40ID that can be subsequently used in any process manipulation functions;
41the child returns from the fork() with a value of C<0> to signify that
42it is the child pseudo-process.
43
44=head2 Behavior of other Perl features in forked pseudo-processes
45
46Most Perl features behave in a natural way within pseudo-processes.
47
48=over 8
49
50=item $$ or $PROCESS_ID
51
52This special variable is correctly set to the pseudo-process ID.
53It can be used to identify pseudo-processes within a particular
54session. Note that this value is subject to recycling if any
55pseudo-processes are launched after others have been wait()-ed on.
56
57=item %ENV
58
4375e838 59Each pseudo-process maintains its own virtual environment. Modifications
7766f137 60to %ENV affect the virtual environment, and are only visible within that
61pseudo-process, and in any processes (or pseudo-processes) launched from
62it.
63
64=item chdir() and all other builtins that accept filenames
65
66Each pseudo-process maintains its own virtual idea of the current directory.
67Modifications to the current directory using chdir() are only visible within
68that pseudo-process, and in any processes (or pseudo-processes) launched from
69it. All file and directory accesses from the pseudo-process will correctly
70map the virtual working directory to the real working directory appropriately.
71
72=item wait() and waitpid()
73
74wait() and waitpid() can be passed a pseudo-process ID returned by fork().
75These calls will properly wait for the termination of the pseudo-process
76and return its status.
77
78=item kill()
79
80kill() can be used to terminate a pseudo-process by passing it the ID returned
81by fork(). This should not be used except under dire circumstances, because
82the operating system may not guarantee integrity of the process resources
83when a running thread is terminated. Note that using kill() on a
84pseudo-process() may typically cause memory leaks, because the thread that
85implements the pseudo-process does not get a chance to clean up its resources.
86
87=item exec()
88
89Calling exec() within a pseudo-process actually spawns the requested
90executable in a separate process and waits for it to complete before
91exiting with the same exit status as that process. This means that the
92process ID reported within the running executable will be different from
93what the earlier Perl fork() might have returned. Similarly, any process
94manipulation functions applied to the ID returned by fork() will affect the
95waiting pseudo-process that called exec(), not the real process it is
96waiting for after the exec().
97
98=item exit()
99
100exit() always exits just the executing pseudo-process, after automatically
101wait()-ing for any outstanding child pseudo-processes. Note that this means
102that the process as a whole will not exit unless all running pseudo-processes
103have exited.
104
105=item Open handles to files, directories and network sockets
106
107All open handles are dup()-ed in pseudo-processes, so that closing
108any handles in one process does not affect the others. See below for
109some limitations.
110
111=back
112
113=head2 Resource limits
114
115In the eyes of the operating system, pseudo-processes created via the fork()
116emulation are simply threads in the same process. This means that any
117process-level limits imposed by the operating system apply to all
118pseudo-processes taken together. This includes any limits imposed by the
119operating system on the number of open file, directory and socket handles,
120limits on disk space usage, limits on memory size, limits on CPU utilization
121etc.
122
123=head2 Killing the parent process
124
125If the parent process is killed (either using Perl's kill() builtin, or
126using some external means) all the pseudo-processes are killed as well,
127and the whole process exits.
128
129=head2 Lifetime of the parent process and pseudo-processes
130
131During the normal course of events, the parent process and every
132pseudo-process started by it will wait for their respective pseudo-children
133to complete before they exit. This means that the parent and every
134pseudo-child created by it that is also a pseudo-parent will only exit
135after their pseudo-children have exited.
136
137A way to mark a pseudo-processes as running detached from their parent (so
138that the parent would not have to wait() for them if it doesn't want to)
139will be provided in future.
140
141=head2 CAVEATS AND LIMITATIONS
142
143=over 8
144
145=item BEGIN blocks
146
147The fork() emulation will not work entirely correctly when called from
148within a BEGIN block. The forked copy will run the contents of the
149BEGIN block, but will not continue parsing the source stream after the
150BEGIN block. For example, consider the following code:
151
152 BEGIN {
153 fork and exit; # fork child and exit the parent
154 print "inner\n";
155 }
156 print "outer\n";
157
158This will print:
159
160 inner
161
162rather than the expected:
163
164 inner
165 outer
166
167This limitation arises from fundamental technical difficulties in
168cloning and restarting the stacks used by the Perl parser in the
169middle of a parse.
170
171=item Open filehandles
172
173Any filehandles open at the time of the fork() will be dup()-ed. Thus,
174the files can be closed independently in the parent and child, but beware
175that the dup()-ed handles will still share the same seek pointer. Changing
176the seek position in the parent will change it in the child and vice-versa.
177One can avoid this by opening files that need distinct seek pointers
178separately in the child.
179
030866aa 180=item Forking pipe open() not yet implemented
181
182The C<open(FOO, "|-")> and C<open(BAR, "-|")> constructs are not yet
183implemented. This limitation can be easily worked around in new code
184by creating a pipe explicitly. The following example shows how to
185write to a forked child:
186
187 # simulate open(FOO, "|-")
188 sub pipe_to_fork ($) {
189 my $parent = shift;
190 pipe my $child, $parent or die;
191 my $pid = fork();
192 die "fork() failed: $!" unless defined $pid;
193 if ($pid) {
194 close $child;
195 }
196 else {
197 close $parent;
198 open(STDIN, "<&=" . fileno($child)) or die;
199 }
200 $pid;
201 }
202
203 if (pipe_to_fork('FOO')) {
204 # parent
205 print FOO "pipe_to_fork\n";
206 close FOO;
207 }
208 else {
209 # child
210 while (<STDIN>) { print; }
211 close STDIN;
212 exit(0);
213 }
214
215And this one reads from the child:
216
217 # simulate open(FOO, "-|")
218 sub pipe_from_fork ($) {
219 my $parent = shift;
220 pipe $parent, my $child or die;
221 my $pid = fork();
222 die "fork() failed: $!" unless defined $pid;
223 if ($pid) {
224 close $child;
225 }
226 else {
227 close $parent;
228 open(STDOUT, ">&=" . fileno($child)) or die;
229 }
230 $pid;
231 }
232
233 if (pipe_from_fork('BAR')) {
234 # parent
235 while (<BAR>) { print; }
236 close BAR;
237 }
238 else {
239 # child
240 print "pipe_from_fork\n";
241 close STDOUT;
242 exit(0);
243 }
244
245Forking pipe open() constructs will be supported in future.
246
7766f137 247=item Global state maintained by XSUBs
248
249External subroutines (XSUBs) that maintain their own global state may
250not work correctly. Such XSUBs will either need to maintain locks to
251protect simultaneous access to global data from different pseudo-processes,
252or maintain all their state on the Perl symbol table, which is copied
253naturally when fork() is called. A callback mechanism that provides
254extensions an opportunity to clone their state will be provided in the
255near future.
256
257=item Interpreter embedded in larger application
258
259The fork() emulation may not behave as expected when it is executed in an
260application which embeds a Perl interpreter and calls Perl APIs that can
261evaluate bits of Perl code. This stems from the fact that the emulation
262only has knowledge about the Perl interpreter's own data structures and
263knows nothing about the containing application's state. For example, any
264state carried on the application's own call stack is out of reach.
265
7e396c59 266=item Thread-safety of extensions
267
268Since the fork() emulation runs code in multiple threads, extensions
269calling into non-thread-safe libraries may not work reliably when
270calling fork(). As Perl's threading support gradually becomes more
271widely adopted even on platforms with a native fork(), such extensions
272are expected to be fixed for thread-safety.
273
7766f137 274=back
275
276=head1 BUGS
277
278=over 8
279
280=item *
281
c7fa416b 282Perl's regular expression engine currently does not play very nicely
283with the fork() emulation. There are known race conditions arising
284from the regular expression engine modifying state carried in the opcode
285tree at run time (the fork() emulation relies on the opcode tree being
286immutable). This typically happens when the regex contains paren groups
287or variables interpolated within it that force a run time recompilation
288of the regex. Due to this major bug, the fork() emulation is not
289recommended for use in production applications at this time.
290
291=item *
292
7766f137 293Having pseudo-process IDs be negative integers breaks down for the integer
294C<-1> because the wait() and waitpid() functions treat this number as
295being special. The tacit assumption in the current implementation is that
296the system never allocates a thread ID of C<1> for user threads. A better
297representation for pseudo-process IDs will be implemented in future.
298
299=item *
300
301This document may be incomplete in some respects.
302
a45bd81d 303=back
304
7766f137 305=head1 AUTHOR
306
7e396c59 307Support for concurrent interpreters and the fork() emulation was implemented
308by ActiveState, with funding from Microsoft Corporation.
7766f137 309
310This document is authored and maintained by Gurusamy Sarathy
311E<lt>gsar@activestate.comE<gt>.
312
313=head1 SEE ALSO
314
315L<perlfunc/"fork">, L<perlipc>
316
317=cut