intro-to-stackless.txt

==============================
Getting Started With Stackless
==============================

This chapter provides a brief introduction to stackless' primitives.  Later
chapters will build on these primitives to show more practical functionality.

--------
Tasklets
--------

Tasklets are the primary building block for stackless.  You create a tasklet by
feeding it any python callable (usually a function or class method).  This
creates a tasklet and adds it to the scheduler.  Here is a quick
demonstration::

    Python 2.4.3 Stackless 3.1b3 060504 (#69, May  3 2006, 19:20:41) [MSC v.1310 32
    bit (Intel)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import stackless
    >>>
    >>> def print_x(x):
    ...     print x
    ...
    >>> stackless.tasklet(print_x)('one')
    <stackless.tasklet object at 0x00A45870>
    >>> stackless.tasklet(print_x)('two')
    <stackless.tasklet object at 0x00A45A30>
    >>> stackless.tasklet(print_x)('three')
    <stackless.tasklet object at 0x00A45AB0>
    >>>
    >>> stackless.run()
    one
    two
    three
    >>>

Note that the tasklets queue up and don't run until you call *stackless.run()*.

-------------
The Scheduler
-------------

The scheduler controls the order in which the tasklets are run.  If you just
create a bunch of tasklets, they will run in the order they are created.  In
practice, you will generally create tasklets that reschedule themselves so that
each one can have it's turn.  A quick demonstration::

    Python 2.4.3 Stackless 3.1b3 060504 (#69, May  3 2006, 19:20:41) [MSC v.1310 32
    bit (Intel)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import stackless
    >>>
    >>> def print_three_times(x):
    ...     print "1:", x
    ...     stackless.schedule()
    ...     print "2:", x
    ...     stackless.schedule()
    ...     print "3:", x
    ...     stackless.schedule()
    ...
    >>>
    >>> stackless.tasklet(print_three_times)('first')
    <stackless.tasklet object at 0x00A45870>
    >>> stackless.tasklet(print_three_times)('second')
    <stackless.tasklet object at 0x00A45A30>
    >>> stackless.tasklet(print_three_times)('third')
    <stackless.tasklet object at 0x00A45AB0>
    >>>
    >>> stackless.run()
    1: first
    1: second
    1: third
    2: first
    2: second
    2: third
    3: first
    3: second
    3: third
    >>>

Note that when we call *stackless.schedule()*, the active tasklet pauses
itself and reinserts itself into the end of the scheduler's queue, allowing the
next tasklet to run.  Once all of the tasklets ahead of this run, it picks up
where it left off.  This continues until all active tasklets have finished
running.  This is how we achieve cooperative multitasking with stackless.

--------
Channels
--------

Channels allow you to send information between tasklets.  This accomplished two
things:

    1. It allows you to exchange information between tasklets.

    2. It allows you to control the flow of execution.

Another quick demonstration::

    C:\>c:\python24\python
    Python 2.4.3 Stackless 3.1b3 060504 (#69, May  3 2006, 19:20:41) [MSC v.1310 32
    bit (Intel)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import stackless
    >>>
    >>> channel = stackless.channel()
    >>>
    >>> def receiving_tasklet():
    ...     print "Recieving tasklet started"
    ...     print channel.receive()
    ...     print "Receiving tasklet finished"
    ...
    >>> def sending_tasklet():
    ...     print "Sending tasklet started"
    ...     channel.send("send from sending_tasklet")
    ...     print "sending tasklet finished"
    ...
    >>> def another_tasklet():
    ...     print "Just another tasklet in the scheduler"
    ...
    >>> stackless.tasklet(receiving_tasklet)()
    <stackless.tasklet object at 0x00A45B30>
    >>> stackless.tasklet(sending_tasklet)()
    <stackless.tasklet object at 0x00A45B70>
    >>> stackless.tasklet(another_tasklet)()
    <stackless.tasklet object at 0x00A45BF0>
    >>>
    >>> stackless.run()
    Recieving tasklet started
    Sending tasklet started
    send from sending_tasklet
    Receiving tasklet finished
    Just another tasklet in the scheduler
    sending tasklet finished
    >>>
    >>>

When the receiving tasklet calls *channel.receive()*, it blocks.  This means
the tasklet pauses until something is sent over the channel.  Nothing other
than sending something over the channel will re-activate the tasklet.

When something is sent over the channel by the sending tasklet, the receiving
tasklet resumes immediately, bypassing the existing schedule.  The sending
tasklet is send to the back of the schedule, as if *stackless.schedule()* had
been called.

Also note that a send will block if there is nothing to immediately receive the
message::

    >>>
    >>> stackless.tasklet(sending_tasklet)()
    <stackless.tasklet object at 0x00A45B70>
    >>> stackless.tasklet(another_tasklet)()
    <stackless.tasklet object at 0x00A45BF0>
    >>>
    >>> stackless.run()
    Sending tasklet started
    Just another tasklet in the scheduler
    >>>
    >>> stackless.tasklet(another_tasklet)()
    <stackless.tasklet object at 0x00A45B30>
    >>> stackless.run()
    Just another tasklet in the scheduler
    >>>
    >>> #Finally adding the receiving tasklet
    ...
    >>> stackless.tasklet(receiving_tasklet)()
    <stackless.tasklet object at 0x00A45BF0>
    >>>
    >>> stackless.run()
    Recieving tasklet started
    send from sending_tasklet
    Receiving tasklet finished
    sending tasklet finished
    >>>

The sending tasklet will not be re-inserted into the scheduler until it has
successfully send data to another tasklet.


-------
Summary
-------

That covers a majority of stackless' functionality.  Doesn't seem like much
does it?  We dealt with a couple of objects and maybe 4 or 5 function calls.
By using this small API as our building blocks, we can start to do some really
interesting things.