ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/Coro/Coro.pm
(Generate patch)

Comparing Coro/Coro.pm (file contents):
Revision 1.42 by root, Tue Nov 6 20:37:20 2001 UTC vs.
Revision 1.66 by root, Thu Mar 3 17:20:31 2005 UTC

… …
30 30
31=cut 31=cut
32 32
33package Coro; 33package Coro;
34 34
35no warnings qw(uninitialized); 35BEGIN { eval { require warnings } && warnings->unimport ("uninitialized") }
36 36
37use Coro::State; 37use Coro::State;
38 38
39use vars qw($idle $main $current);
40
39use base Exporter; 41use base Exporter;
40 42
41$VERSION = 0.52; 43$VERSION = 1.11;
42 44
43@EXPORT = qw(async cede schedule terminate current); 45@EXPORT = qw(async cede schedule terminate current);
44%EXPORT_TAGS = ( 46%EXPORT_TAGS = (
45 prio => [qw(PRIO_MAX PRIO_HIGH PRIO_NORMAL PRIO_LOW PRIO_IDLE PRIO_MIN)], 47 prio => [qw(PRIO_MAX PRIO_HIGH PRIO_NORMAL PRIO_LOW PRIO_IDLE PRIO_MIN)],
46); 48);
… …
75 }; 77 };
76 } 78 }
77 79
78} 80}
79 81
82=over 4
83
80=item $main 84=item $main
81 85
82This coroutine represents the main program. 86This coroutine represents the main program.
83 87
84=cut 88=cut
85 89
86our $main = new Coro; 90$main = new Coro;
87 91
88=item $current (or as function: current) 92=item $current (or as function: current)
89 93
90The current coroutine (the last coroutine switched to). The initial value is C<$main> (of course). 94The current coroutine (the last coroutine switched to). The initial value is C<$main> (of course).
91 95
… …
94# maybe some other module used Coro::Specific before... 98# maybe some other module used Coro::Specific before...
95if ($current) { 99if ($current) {
96 $main->{specific} = $current->{specific}; 100 $main->{specific} = $current->{specific};
97} 101}
98 102
99our $current = $main; 103$current = $main;
100 104
101sub current() { $current } 105sub current() { $current }
102 106
103=item $idle 107=item $idle
104 108
… …
106implementation prints "FATAL: deadlock detected" and exits. 110implementation prints "FATAL: deadlock detected" and exits.
107 111
108=cut 112=cut
109 113
110# should be done using priorities :( 114# should be done using priorities :(
111our $idle = new Coro sub { 115$idle = new Coro sub {
112 print STDERR "FATAL: deadlock detected\n"; 116 print STDERR "FATAL: deadlock detected\n";
113 exit(51); 117 exit(51);
114}; 118};
115 119
116# this coroutine is necessary because a coroutine 120# this coroutine is necessary because a coroutine
117# cannot destroy itself. 121# cannot destroy itself.
118my @destroy; 122my @destroy;
119my $manager; 123my $manager;
120$manager = new Coro sub { 124$manager = new Coro sub {
121 while() { 125 while () {
122 # by overwriting the state object with the manager we destroy it 126 # by overwriting the state object with the manager we destroy it
123 # while still being able to schedule this coroutine (in case it has 127 # while still being able to schedule this coroutine (in case it has
124 # been readied multiple times. this is harmless since the manager 128 # been readied multiple times. this is harmless since the manager
125 # can be called as many times as neccessary and will always 129 # can be called as many times as neccessary and will always
126 # remove itself from the runqueue 130 # remove itself from the runqueue
127 while (@destroy) { 131 while (@destroy) {
128 my $coro = pop @destroy; 132 my $coro = pop @destroy;
129 $coro->{status} ||= []; 133 $coro->{status} ||= [];
130 $_->ready for @{delete $coro->{join} || []}; 134 $_->ready for @{delete $coro->{join} || []};
135
136 # the next line destroys the _coro_state, but keeps the
137 # process itself intact (we basically make it a zombie
138 # process that always runs the manager thread, so it's possible
139 # to transfer() to this process).
131 $coro->{_coro_state} = $manager->{_coro_state}; 140 $coro->{_coro_state} = $manager->{_coro_state};
132 } 141 }
133 &schedule; 142 &schedule;
134 } 143 }
135}; 144};
136 145
137# static methods. not really. 146# static methods. not really.
138 147
148=back
149
139=head2 STATIC METHODS 150=head2 STATIC METHODS
140 151
141Static methods are actually functions that operate on the current process only. 152Static methods are actually functions that operate on the current process only.
142 153
143=over 4 154=over 4
… …
150 161
151 # create a new coroutine that just prints its arguments 162 # create a new coroutine that just prints its arguments
152 async { 163 async {
153 print "@_\n"; 164 print "@_\n";
154 } 1,2,3,4; 165 } 1,2,3,4;
155
156The coderef you submit MUST NOT be a closure that refers to variables
157in an outer scope. This does NOT work. Pass arguments into it instead.
158 166
159=cut 167=cut
160 168
161sub async(&@) { 169sub async(&@) {
162 my $pid = new Coro @_; 170 my $pid = new Coro @_;
… …
181 189
182=cut 190=cut
183 191
184=item terminate [arg...] 192=item terminate [arg...]
185 193
186Terminates the current process. 194Terminates the current process with the given status values (see L<cancel>).
187
188Future versions of this function will allow result arguments.
189 195
190=cut 196=cut
191 197
192sub terminate { 198sub terminate {
193 $current->{status} = [@_];
194 $current->cancel; 199 $current->cancel (@_);
195 &schedule;
196 die; # NORETURN
197} 200}
198 201
199=back 202=back
200 203
201# dynamic methods 204# dynamic methods
… …
230 233
231Put the given process into the ready queue. 234Put the given process into the ready queue.
232 235
233=cut 236=cut
234 237
235=item $process->cancel 238=item $process->cancel (arg...)
236 239
237Like C<terminate>, but terminates the specified process instead. 240Temrinates the given process and makes it return the given arguments as
241status (default: the empty list).
238 242
239=cut 243=cut
240 244
241sub cancel { 245sub cancel {
246 my $self = shift;
247 $self->{status} = [@_];
242 push @destroy, $_[0]; 248 push @destroy, $self;
243 $manager->ready; 249 $manager->ready;
244 &schedule if $current == $_[0]; 250 &schedule if $current == $self;
245} 251}
246 252
247=item $process->join 253=item $process->join
248 254
249Wait until the coroutine terminates and return any values given to the 255Wait until the coroutine terminates and return any values given to the
250C<terminate> function. C<join> can be called multiple times from multiple 256C<terminate> or C<cancel> functions. C<join> can be called multiple times
251processes. 257from multiple processes.
252 258
253=cut 259=cut
254 260
255sub join { 261sub join {
256 my $self = shift; 262 my $self = shift;
… …
263 269
264=item $oldprio = $process->prio($newprio) 270=item $oldprio = $process->prio($newprio)
265 271
266Sets (or gets, if the argument is missing) the priority of the 272Sets (or gets, if the argument is missing) the priority of the
267process. Higher priority processes get run before lower priority 273process. Higher priority processes get run before lower priority
268processes. Priorities are smalled signed integer (currently -4 .. +3), 274processes. Priorities are small signed integers (currently -4 .. +3),
269that you can refer to using PRIO_xxx constants (use the import tag :prio 275that you can refer to using PRIO_xxx constants (use the import tag :prio
270to get then): 276to get then):
271 277
272 PRIO_MAX > PRIO_HIGH > PRIO_NORMAL > PRIO_LOW > PRIO_IDLE > PRIO_MIN 278 PRIO_MAX > PRIO_HIGH > PRIO_NORMAL > PRIO_LOW > PRIO_IDLE > PRIO_MIN
273 3 > 1 > 0 > -1 > -3 > -4 279 3 > 1 > 0 > -1 > -3 > -4
… …
321 327
3221; 3281;
323 329
324=head1 BUGS/LIMITATIONS 330=head1 BUGS/LIMITATIONS
325 331
326 - you must make very sure that no coro is still active on global destruction. 332 - you must make very sure that no coro is still active on global
327 very bad things might happen otherwise (usually segfaults). 333 destruction. very bad things might happen otherwise (usually segfaults).
334
328 - this module is not thread-safe. You should only ever use this module from 335 - this module is not thread-safe. You should only ever use this module
329 the same thread (this requirement might be loosened in the future to 336 from the same thread (this requirement might be losened in the future
330 allow per-thread schedulers, but Coro::State does not yet allow this). 337 to allow per-thread schedulers, but Coro::State does not yet allow
338 this).
331 339
332=head1 SEE ALSO 340=head1 SEE ALSO
333 341
334L<Coro::Channel>, L<Coro::Cont>, L<Coro::Specific>, L<Coro::Semaphore>, 342L<Coro::Channel>, L<Coro::Cont>, L<Coro::Specific>, L<Coro::Semaphore>,
335L<Coro::Signal>, L<Coro::State>, L<Coro::Event>, L<Coro::RWLock>, 343L<Coro::Signal>, L<Coro::State>, L<Coro::Timer>, L<Coro::Event>,
336L<Coro::Handle>, L<Coro::Socket>. 344L<Coro::Handle>, L<Coro::RWLock>, L<Coro::Socket>.
337 345
338=head1 AUTHOR 346=head1 AUTHOR
339 347
340 Marc Lehmann <pcg@goof.com> 348 Marc Lehmann <schmorp@schmorp.de>
341 http://www.goof.com/pcg/marc/ 349 http://home.schmorp.de/
342 350
343=cut 351=cut
344 352

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines