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

Comparing Coro/Coro.pm (file contents):
Revision 1.8 by root, Sat Jul 14 22:14:21 2001 UTC vs.
Revision 1.19 by root, Sat Jul 21 03:44:06 2001 UTC

… …
18 18
19 yield; 19 yield;
20 20
21=head1 DESCRIPTION 21=head1 DESCRIPTION
22 22
23This module collection manages coroutines. Coroutines are similar to
24Threads but don't run in parallel.
25
26This module is still experimental, see the BUGS section below.
27
23=cut 28=cut
24 29
25package Coro; 30package Coro;
26 31
27use Coro::State; 32use Coro::State;
28 33
29use base Exporter; 34use base Exporter;
30 35
31$VERSION = 0.03; 36$VERSION = 0.09;
32 37
33@EXPORT = qw(async yield schedule); 38@EXPORT = qw(async yield schedule terminate current);
34@EXPORT_OK = qw($current); 39@EXPORT_OK = qw($current);
35 40
36{ 41{
37 use subs 'async'; 42 use subs 'async';
38 43
… …
47 my @attrs; 52 my @attrs;
48 for (@_) { 53 for (@_) {
49 if ($_ eq "Coro") { 54 if ($_ eq "Coro") {
50 push @async, $ref; 55 push @async, $ref;
51 } else { 56 } else {
52 push @attrs, @_; 57 push @attrs, $_;
53 } 58 }
54 } 59 }
55 return $old ? $old->($package, $name, @attrs) : @attrs; 60 return $old ? $old->($package, $ref, @attrs) : @attrs;
56 }; 61 };
57 } 62 }
58 63
59 sub INIT { 64 sub INIT {
60 async pop @async while @async; 65 async pop @async while @async;
61 } 66 }
62} 67}
63 68
64my $idle = new Coro sub {
65 &yield while 1;
66};
67
68=item $main 69=item $main
69 70
70This coroutine represents the main program. 71This coroutine represents the main program.
71 72
72=cut 73=cut
73 74
74$main = new Coro; 75our $main = new Coro;
75 76
76=item $current 77=item $current (or as function: current)
77 78
78The current coroutine (the last coroutine switched to). The initial value is C<$main> (of course). 79The current coroutine (the last coroutine switched to). The initial value is C<$main> (of course).
79 80
80=cut 81=cut
81 82
82# maybe some other module used Coro::Specific before... 83# maybe some other module used Coro::Specific before...
83if ($current) { 84if ($current) {
84 $main->{specific} = $current->{specific}; 85 $main->{specific} = $current->{specific};
85} 86}
86 87
87$current = $main; 88our $current = $main;
89
90sub current() { $current }
91
92=item $idle
93
94The coroutine to switch to when no other coroutine is running. The default
95implementation prints "FATAL: deadlock detected" and exits.
96
97=cut
98
99# should be done using priorities :(
100our $idle = new Coro sub {
101 print STDERR "FATAL: deadlock detected\n";
102 exit(51);
103};
88 104
89# we really need priorities... 105# we really need priorities...
90my @ready = (); # the ready queue. hehe, rather broken ;) 106my @ready; # the ready queue. hehe, rather broken ;)
91 107
92# static methods. not really. 108# static methods. not really.
93 109
94=head2 STATIC METHODS 110=head2 STATIC METHODS
95 111
96Static methods are actually functions that operate on the current process only. 112Static methods are actually functions that operate on the current process only.
97 113
98=over 4 114=over 4
99 115
100=item async { ... }; 116=item async { ... } [@args...]
101 117
102Create a new asynchronous process and return it's process object 118Create a new asynchronous process and return it's process object
103(usually unused). When the sub returns the new process is automatically 119(usually unused). When the sub returns the new process is automatically
104terminated. 120terminated.
105 121
106=cut 122 # create a new coroutine that just prints its arguments
123 async {
124 print "@_\n";
125 } 1,2,3,4;
107 126
127The coderef you submit MUST NOT be a closure that refers to variables
128in an outer scope. This does NOT work. Pass arguments into it instead.
129
130=cut
131
108sub async(&) { 132sub async(&@) {
109 (new Coro $_[0])->ready; 133 my $pid = new Coro @_;
134 $pid->ready;
135 $pid;
110} 136}
111 137
112=item schedule 138=item schedule
113 139
114Calls the scheduler. Please note that the current process will not be put 140Calls the scheduler. Please note that the current process will not be put
… …
118=cut 144=cut
119 145
120my $prev; 146my $prev;
121 147
122sub schedule { 148sub schedule {
149 # should be done using priorities :(
123 ($prev, $current) = ($current, shift @ready); 150 ($prev, $current) = ($current, shift @ready || $idle);
124 Coro::State::transfer($prev, $current); 151 Coro::State::transfer($prev, $current);
125} 152}
126 153
127=item yield 154=item yield
128 155
… …
138 165
139=item terminate 166=item terminate
140 167
141Terminates the current process. 168Terminates the current process.
142 169
170Future versions of this function will allow result arguments.
171
143=cut 172=cut
144 173
145sub terminate { 174sub terminate {
175 $current->{_results} = [@_];
146 &schedule; 176 &schedule;
147} 177}
148 178
149=back 179=back
150 180
… …
154 184
155These are the methods you can call on process objects. 185These are the methods you can call on process objects.
156 186
157=over 4 187=over 4
158 188
159=item new Coro \&sub; 189=item new Coro \&sub [, @args...]
160 190
161Create a new process and return it. When the sub returns the process 191Create a new process and return it. When the sub returns the process
162automatically terminates. To start the process you must first put it into 192automatically terminates. To start the process you must first put it into
163the ready queue by calling the ready method. 193the ready queue by calling the ready method.
164 194
195The coderef you submit MUST NOT be a closure that refers to variables
196in an outer scope. This does NOT work. Pass arguments into it instead.
197
165=cut 198=cut
199
200sub _newcoro {
201 terminate &{+shift};
202}
166 203
167sub new { 204sub new {
168 my $class = shift; 205 my $class = shift;
169 my $proc = $_[0];
170 bless { 206 bless {
171 _coro_state => new Coro::State ($proc ? sub { &$proc; &terminate } : $proc), 207 _coro_state => (new Coro::State $_[0] && \&_newcoro, @_),
172 }, $class; 208 }, $class;
173} 209}
174 210
175=item $process->ready 211=item $process->ready
176 212
… …
186 222
187=cut 223=cut
188 224
1891; 2251;
190 226
227=head1 BUGS/LIMITATIONS
228
229 - could be faster, especially when the core would introduce special
230 support for coroutines (like it does for threads).
231 - there is still a memleak on coroutine termination that I could not
232 identify. Could be as small as a single SV.
233 - this module is not well-tested.
234 - if variables or arguments "disappear" (become undef) or become
235 corrupted please contact the author so he cen iron out the
236 remaining bugs.
237 - this module is not thread-safe. You must only ever use this module from
238 the same thread (this requirement might be loosened in the future to
239 allow per-thread schedulers, but Coro::Satte does not yet allow this).
240
241=head1 SEE ALSO
242
243L<Coro::Channel>, L<Coro::Cont>, L<Coro::Specific>, L<Coro::Semaphore>,
244L<Coro::Signal>, L<Coro::State>, L<Coro::Event>.
245
191=head1 AUTHOR 246=head1 AUTHOR
192 247
193 Marc Lehmann <pcg@goof.com> 248 Marc Lehmann <pcg@goof.com>
194 http://www.goof.com/pcg/marc/ 249 http://www.goof.com/pcg/marc/
195 250

Diff Legend

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