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

Comparing Coro/Coro.pm (file contents):
Revision 1.12 by root, Sun Jul 15 15:58:16 2001 UTC vs.
Revision 1.14 by root, Tue Jul 17 02:21:56 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.05; 36$VERSION = 0.05;
32 37
33@EXPORT = qw(async yield schedule); 38@EXPORT = qw(async yield schedule terminate);
34@EXPORT_OK = qw($current); 39@EXPORT_OK = qw($current);
35 40
36{ 41{
37 use subs 'async'; 42 use subs 'async';
38 43
… …
94 print STDERR "FATAL: deadlock detected\n"; 99 print STDERR "FATAL: deadlock detected\n";
95 exit(51); 100 exit(51);
96}; 101};
97 102
98# we really need priorities... 103# we really need priorities...
104## my @ready; #d#
99my @ready = (); # the ready queue. hehe, rather broken ;) 105our @ready = (); # the ready queue. hehe, rather broken ;)
100 106
101# static methods. not really. 107# static methods. not really.
102 108
103=head2 STATIC METHODS 109=head2 STATIC METHODS
104 110
105Static methods are actually functions that operate on the current process only. 111Static methods are actually functions that operate on the current process only.
106 112
107=over 4 113=over 4
108 114
109=item async { ... }; 115=item async { ... } [@args...]
110 116
111Create a new asynchronous process and return it's process object 117Create a new asynchronous process and return it's process object
112(usually unused). When the sub returns the new process is automatically 118(usually unused). When the sub returns the new process is automatically
113terminated. 119terminated.
114 120
115=cut 121 # create a new coroutine that just prints its arguments
122 async {
123 print "@_\n";
124 } 1,2,3,4;
116 125
126The coderef you submit MUST NOT be a closure that refers to variables
127in an outer scope. This does NOT work. Pass arguments into it instead.
128
129=cut
130
117sub async(&) { 131sub async(&@) {
118 my $pid = new Coro $_[0]; 132 my $pid = new Coro @_;
119 $pid->ready; 133 $pid->ready;
120 $pid; 134 $pid;
121} 135}
122 136
123=item schedule 137=item schedule
… …
129=cut 143=cut
130 144
131my $prev; 145my $prev;
132 146
133sub schedule { 147sub schedule {
134 local @_;
135 # should be done using priorities :( 148 # should be done using priorities :(
136 ($prev, $current) = ($current, shift @ready || $idle); 149 ($prev, $current) = ($current, shift @ready || $idle);
137 Coro::State::transfer($prev, $current); 150 Coro::State::transfer($prev, $current);
138} 151}
139 152
… …
151 164
152=item terminate 165=item terminate
153 166
154Terminates the current process. 167Terminates the current process.
155 168
169Future versions of this function will allow result arguments.
170
156=cut 171=cut
157 172
158sub terminate { 173sub terminate {
174 $current->{_results} = [@_];
159 &schedule; 175 &schedule;
160} 176}
161 177
162=back 178=back
163 179
… …
167 183
168These are the methods you can call on process objects. 184These are the methods you can call on process objects.
169 185
170=over 4 186=over 4
171 187
172=item new Coro \⊂ 188=item new Coro \&sub [, @args...]
173 189
174Create a new process and return it. When the sub returns the process 190Create a new process and return it. When the sub returns the process
175automatically terminates. To start the process you must first put it into 191automatically terminates. To start the process you must first put it into
176the ready queue by calling the ready method. 192the ready queue by calling the ready method.
177 193
194The coderef you submit MUST NOT be a closure that refers to variables
195in an outer scope. This does NOT work. Pass arguments into it instead.
196
178=cut 197=cut
198
199sub _newcoro {
200 terminate &{+shift};
201}
179 202
180sub new { 203sub new {
181 my $class = shift; 204 my $class = shift;
182 my $proc = $_[0];
183 bless { 205 bless {
184 _coro_state => new Coro::State ($proc ? sub { &$proc; &terminate } : $proc), 206 _coro_state => (new Coro::State $_[0] && \&_newcoro, @_),
185 }, $class; 207 }, $class;
186} 208}
187 209
188=item $process->ready 210=item $process->ready
189 211
… …
199 221
200=cut 222=cut
201 223
2021; 2241;
203 225
226=head1 BUGS
227
228 - could be faster, especially when the core would introduce special
229 support for coroutines (like it does for threads).
230 - there is still a memleak on coroutine termination that I could not
231 identify. Could be as small as a single SV.
232 - this module is not well-tested.
233
204=head1 SEE ALSO 234=head1 SEE ALSO
205 235
206L<Coro::Channel>, L<Coro::Cont>, L<Coro::Specific>, L<Coro::Semaphore>, 236L<Coro::Channel>, L<Coro::Cont>, L<Coro::Specific>, L<Coro::Semaphore>,
207L<Coro::Signal>, L<Coro::State>, L<Coro::Event>. 237L<Coro::Signal>, L<Coro::State>, L<Coro::Event>.
208 238

Diff Legend

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