Acme-Parataxis
view release on metacpan or search on metacpan
Creating a fiber does not run it immediately. It simply prepares the context and waits to be invoked.
## Invoking Fibers
To run a fiber, you "call" it. This suspends the current fiber and executes the called one until it finishes or yields.
```
$fiber->call( );
```
When the called fiber finishes, control returns to the fiber that called it. It is an error to call a fiber that is
already done.
## Yielding
Yielding is the "secret sauce" of fibers.
A yielded fiber passes control back to its caller but remembers its exact state including all variables and the current
instruction pointer. The next time it's called, it resumes exactly where it left off.
```
## `is_done( )`
Returns true if the fiber has finished execution (either by returning or dying). Once a fiber is done, its internal ID
is released and it can no longer be called.
# Acme::Parataxis::Future OBJECT METHODS
## `await( )`
Suspends the current fiber until the future is ready. Returns the result or **dies** if the task encountered an error.
## `is_ready( )`
Returns true if the task associated with the future has completed.
## `result( )`
Returns the task result immediately. Croaks if the future is not yet ready.
# INTEGRATING SYNCHRONOUS MODULES
builder/Acme/Parataxis/Builder.pm view on Meta::CPAN
}
method step_realclean () { rmtree( $_, $verbose ) for qw[blib temp Build _build_params MYMETA.yml MYMETA.json]; 0 }
method step_test() {
$self->step_build() unless -d 'blib';
require TAP::Harness::Env;
require Config;
my @libs = map { rel2abs( catdir( 'blib', $_ ) ) } qw[arch lib];
local $ENV{PERL5LIB} = join( $Config::Config{path_sep}, @libs, ( defined $ENV{PERL5LIB} ? $ENV{PERL5LIB} : () ) );
my %test_args = ( ( verbosity => $verbose ), ( jobs => $jobs ), ( color => -t STDOUT ), lib => [@libs], );
TAP::Harness::Env->create( \%test_args )->runtests( sort map { $_->stringify } find( qr/\.t$/, 't' ) )->has_errors;
}
method get_arguments (@sources) {
$_ = detildefy($_) for grep {defined} $install_base, $destdir, $prefix, values %{$install_paths};
$install_paths = ExtUtils::InstallPaths->new( dist_name => $meta->name );
return;
}
method Build(@args) {
my $method = $self->can( 'step_' . $action );
lib/Acme/Parataxis.c view on Meta::CPAN
PMOP * reg_curpm; /**< Current regex match state */
GV * defgv; /**< The $_ global */
GV * last_in_gv; /**< GV used in last <FH> */
SV * rs; /**< The $/ global */
GV * ofsgv; /**< The $, global */
SV * ors_sv; /**< The $\ global */
GV * defoutgv; /**< The default output filehandle */
HV * curstash; /**< Current package stash */
HV * defstash; /**< Default package stash */
SV * errors; /**< Outstanding queued errors */
SV * user_cv; /**< The Perl sub/coderef this fiber is running */
SV * self_ref; /**< The Acme::Parataxis Perl object wrapper */
SV * transfer_data; /**< Arguments or return values passed during yield/transfer */
int id; /**< Numeric ID of this fiber */
int finished; /**< Flag: 1 if the fiber has completed its entry_point */
int parent_id; /**< ID of the fiber that 'called' this one (asymmetric) */
int last_sender; /**< ID of the fiber that last switched control to this one */
lib/Acme/Parataxis.c view on Meta::CPAN
from->curpm_under = PL_curpm_under;
from->reg_curpm = PL_reg_curpm;
from->defgv = PL_defgv;
from->last_in_gv = PL_last_in_gv;
from->rs = PL_rs;
from->ofsgv = PL_ofsgv;
from->ors_sv = PL_ors_sv;
from->defoutgv = PL_defoutgv;
from->curstash = PL_curstash;
from->defstash = PL_defstash;
from->errors = PL_errors;
/* Load target state from 'to' context */
PL_curstackinfo = to->si;
PL_curstack = to->curstack;
// Re-calculate stack bounds based on the new array (AV)
PL_stack_base = AvARRAY(PL_curstack);
PL_stack_max = PL_stack_base + AvMAX(PL_curstack);
PL_stack_sp = PL_stack_base + to->stack_sp_offset;
AvFILLp(PL_curstack) = to->stack_sp_offset; // Keep stack AV metadata synced
lib/Acme/Parataxis.c view on Meta::CPAN
PL_curpm_under = to->curpm_under;
PL_reg_curpm = to->reg_curpm;
PL_defgv = to->defgv;
PL_last_in_gv = to->last_in_gv;
PL_rs = to->rs;
PL_ofsgv = to->ofsgv;
PL_ors_sv = to->ors_sv;
PL_defoutgv = to->defoutgv;
PL_curstash = to->curstash;
PL_defstash = to->defstash;
PL_errors = to->errors;
if (PL_comppad)
PL_curpad = AvARRAY(PL_comppad);
else
PL_curpad = to->curpad;
// Restore CvDEPTH and clean landing pads
_activate_current_depths(aTHX_ to);
}
lib/Acme/Parataxis.c view on Meta::CPAN
c->curpm_under = PL_curpm_under;
c->reg_curpm = NULL;
c->defgv = PL_defgv;
c->last_in_gv = PL_last_in_gv;
c->rs = PL_rs;
c->ofsgv = PL_ofsgv;
c->ors_sv = PL_ors_sv;
c->defoutgv = PL_defoutgv;
c->curstash = PL_curstash;
c->defstash = PL_defstash;
c->errors = PL_errors;
// Start with fresh pads to avoid interfering with caller.
c->comppad = NULL;
c->curpad = NULL;
}
/**
* @brief Initializes the fiber system and converts the main thread.
*
* This function must be called once before any other fiber operations.
lib/Acme/Parataxis.c view on Meta::CPAN
main_context.curpm_under = PL_curpm_under;
main_context.reg_curpm = PL_reg_curpm;
main_context.defgv = PL_defgv;
main_context.last_in_gv = PL_last_in_gv;
main_context.rs = PL_rs;
main_context.ofsgv = PL_ofsgv;
main_context.ors_sv = PL_ors_sv;
main_context.defoutgv = PL_defoutgv;
main_context.curstash = PL_curstash;
main_context.defstash = PL_defstash;
main_context.errors = PL_errors;
system_initialized = 1;
#ifdef _WIN32
/* Convert the main thread into a fiber so it can be switched out */
if (!main_fiber_handle) {
main_fiber_handle = ConvertThreadToFiber(NULL);
if (!main_fiber_handle) {
if (GetLastError() == ERROR_ALREADY_FIBER)
main_fiber_handle = GetCurrentFiber();
}
}
lib/Acme/Parataxis.c view on Meta::CPAN
self->transfer_data = &PL_sv_undef;
if (res && res != &PL_sv_undef)
sv_2mortal(res);
return res;
}
/**
* @brief Entry point function for all new fibers.
*
* Sets up the Perl environment (ENTER/SAVETMPS), unpacks arguments,
* calls the user coderef, handles results/errors, and manages the
* fiber's completion lifecycle.
*
* @param c Pointer to the fiber context being started.
*/
static void entry_point(para_fiber_t * c) {
dTHX;
ENTER;
SAVETMPS;
dSP;
PUSHMARK(SP);
lib/Acme/Parataxis.c view on Meta::CPAN
/* Update the Perl-level Acme::Parataxis object */
if (c->self_ref && SvROK(c->self_ref)) {
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(c->self_ref);
if (SvTRUE(ERRSV)) {
XPUSHs(ERRSV);
PUTBACK;
call_method("set_error", G_DISCARD);
}
else {
XPUSHs(ret_val);
PUTBACK;
call_method("set_result", G_DISCARD);
}
FREETMPS;
LEAVE;
}
FREETMPS;
lib/Acme/Parataxis.c view on Meta::CPAN
#else
/** @brief POSIX makecontext callback wrapper. */
static void posix_entry(int fiber_id) { entry_point(fibers[fiber_id]); }
#endif
/**
* @brief Allocates and prepares a new Fiber context.
*
* @param user_code Coderef to execute in the fiber.
* @param self_ref Acme::Parataxis object to notify on completion.
* @return int Unique ID of the new fiber, or negative on error.
*/
DLLEXPORT int create_fiber(SV * user_code, SV * self_ref) {
dTHX;
int idx = -1;
for (int i = 0; i < MAX_FIBERS; i++) {
if (fibers[i] == NULL) {
idx = i;
break;
}
}
lib/Acme/Parataxis.pm view on Meta::CPAN
usleep(1000);
}
}
}
sub stop () { $IS_RUNNING = 0 }
class #
Acme::Parataxis {
use Carp qw[croak];
field $code : reader : param;
field $is_done = 0;
field $error : reader;
field $result : reader;
field $fid : reader;
field $future : param = undef;
method set_result ($val) {
$result = $val;
$future->set_result($val) if $future;
}
method set_error ($err) {
$error = $err;
$future->set_error($err) if $future;
}
method _clear_result () {
$result = undef;
$error = undef;
}
our %REGISTRY;
ADJUST {
Acme::Parataxis::force_depth_zero($code);
$fid = Acme::Parataxis::create_fiber( $code, $self );
$REGISTRY{$fid} = $self;
builtin::weaken $REGISTRY{$fid};
}
method call (@args) {
croak 'Cannot call a finished fiber' if $is_done;
my $rv = Acme::Parataxis::coro_call( $fid, \@args );
return unless defined $self;
if ( $self->is_done ) {
my $err = $error;
die $err if defined $err;
}
return unless defined $rv;
return ( ref $rv eq 'ARRAY' ) ? ( wantarray ? @$rv : $rv->[-1] ) : $rv;
}
method transfer (@args) {
croak 'Cannot transfer to a finished fiber' if $self->is_done;
my $rv = Acme::Parataxis::coro_transfer( $fid, \@args );
if ( $self->is_done ) {
my $err = $error;
die $err if defined $err;
}
return unless defined $rv;
return ( ref $rv eq 'ARRAY' ) ? ( wantarray ? @$rv : $rv->[-1] ) : $rv;
}
method is_done () {
return 1 if $is_done;
if ( defined $fid && $fid >= 0 && Acme::Parataxis::is_finished($fid) ) {
$is_done = 1;
lib/Acme/Parataxis.pm view on Meta::CPAN
return unless defined $rv;
return ( ref $rv eq 'ARRAY' ) ? ( wantarray ? @$rv : $rv->[-1] ) : $rv;
}
method fid () {-1}
}
class #
Acme::Parataxis::Future {
use Carp qw[croak];
field $is_ready : reader = 0;
field $result;
field $error;
field @callbacks;
method result () {
croak 'Future not ready' unless $is_ready;
return $result;
}
method set_result ($val) {
die 'Future already ready' if $is_ready;
$result = $val;
$is_ready = 1;
$_->($self) for @callbacks;
}
method set_error ($err) {
die 'Future already ready' if $is_ready;
$error = $err;
$is_ready = 1;
$_->($self) for @callbacks;
}
method clear_result () {
$result = undef;
$error = undef;
}
method on_ready ($cb) {
if ($is_ready) { $cb->($self) }
else { push @callbacks, $cb }
}
method await () {
return $self->result if $is_ready;
my $fid = Acme::Parataxis->current_fid;
lib/Acme/Parataxis.pod view on Meta::CPAN
});
Creating a fiber does not run it immediately. It simply prepares the context and waits to be invoked.
=head2 Invoking Fibers
To run a fiber, you "call" it. This suspends the current fiber and executes the called one until it finishes or yields.
$fiber->call( );
When the called fiber finishes, control returns to the fiber that called it. It is an error to call a fiber that is
already done.
=head2 Yielding
Yielding is the "secret sauce" of fibers.
A yielded fiber passes control back to its caller but remembers its exact state including all variables and the current
instruction pointer. The next time it's called, it resumes exactly where it left off.
Acme::Parataxis->yield( );
lib/Acme/Parataxis.pod view on Meta::CPAN
=head2 C<is_done( )>
Returns true if the fiber has finished execution (either by returning or dying). Once a fiber is done, its internal ID
is released and it can no longer be called.
=head1 Acme::Parataxis::Future OBJECT METHODS
=head2 C<await( )>
Suspends the current fiber until the future is ready. Returns the result or B<dies> if the task encountered an error.
=head2 C<is_ready( )>
Returns true if the task associated with the future has completed.
=head2 C<result( )>
Returns the task result immediately. Croaks if the future is not yet ready.
( run in 0.801 second using v1.01-cache-2.11-cpan-c966e8aa7e8 )