NAME
Padre::Task - Padre Task API 2.0
DESCRIPTION
The Padre Task API implements support for background and parallel execution of code in the Padre IDE, and is based on the CPAN Process API.
A Task Class is a class that completely encapsulates a single unit of work, describing not only the work to be done, but also how the unit of work is created, how is serialised for transport, and any initialisation or cleanup work needs to be done.
A Task is a single self-contained unit of work, and is implemented as a single instance of a particular Task Class.
The lifecycle of a Task object
From the perspective of a task author, the execution of a task will occur in four distinct phases.
1. Construction
The creation of a task is always done completely independantly of its execution. Typically this is done via the new method, or something that calls it.
This separate construction step allows validation of parameters in advance, as well as allowing bulk task pre-generation and advanced task management functionality such as prioritisation, queueing, throttling and load-balancing of tasks.
2. Preparation
Once a task has been constructed, an arbitrarily long time may pass before the code is actually run (if it is ever run at all).
If the actual execution of the task will result in certain work being done in the parent thread, this work cannot be done in the constructor. And once created as an object, no futher task code will be called until the task is ready for execution.
To give the author a chance to allow for any problems that may occur as a result of this delay, the Task API provides a preparation phase for the task via the prepare method.
This preparation code is run in the parent thread once the task has been prioritised, has a worker allocated to it, and has been encapsulated in its Padre::TaskHandle, but before the object is serialised for transport into the thread.
A task can use this preparation phase to detach from non-serialisable resources in the object such as database handles, to copy any interesting parent state late rather than early, or decide on a last-second self-abort.
Once the preparation phase is completed the task will be serialised, transported into assigned worker thread and then executed immediately.
Because it will execute in the parent thead, the rest of the Padre instance is available for use if needed, but the preparation code should run quickly and must not block.
3. Execution
The main phase of the task is where the CPU-intensive or blocking code can be safely run. It is run inside a worker thread in the background, without impacting on the performance of the parent thread.
However, the task execution phase must be entirely self-contained.
The worker threads not only do not have access to the Padre IDE variable structure, but most Padre classes (including heavily used modules such as Padre::Current) will not be loaded at all in the worker thread.
Any output that needs to be transported back to the parent should be stored in the object somewhere. When the cleanup phase is run, these values will be available automatically in the parent.
4. Cleanup
TO BE COMPLETED
SEE ALSO
COPYRIGHT
Copyright 2008-2011 The Padre development team as listed in Padre.pm.
This program is free software; you can redistribute it and/or modify it under the same terms as Perl 5 itself.
The full text of the license can be found in the LICENSE file included with this module.