ANN: Axon 1.5.0 RELEASED!

Michael ms at
Thu Jun 22 00:38:50 CEST 2006


I'm extremely pleased to say - Axon 1.5.0 has been released!

Axon is Kamaelia's core concurrency system, largely based around python
generators to enable components to be built following a slightly updated
paraphrasing of Unix Philosophy:

 """Write components that do one thing and do it well.
    Write components to work together.
    Write components to handle python object streams, because that is a
    universal interface."""

(With apologies to Doug McIlroy...) 

Axon essentially provides a way for active objects (generators, threads)
to be composed into pipelines of arbitrary shape (graphlines etc) as a
means of system simplification.

What's Changed?
Axon 1.5 is a major performance related release for Kamaelia's core
component system. There have been a number of core changes, some

  * Zero copy delivery of data from producers to consumers
  * The system scheduler is now reactive to threaded components, meaning the
    system can truly sleep when there is nothing to do.
  * This means self.pause() REALLY pauses the microprocess, and may result
    in the component not receiving data. (If you call self.pause, you should
    really mean it). Generally this is only used at an optimisation stage.
  * Threaded components are now fully supported with the following caveats:
     * They should not use the shared environment provided the co-ordinating
       assistant tracker (they're not expected to need to do so, but this is
       useful to make explicit)
     * They should not expect to be able to interact with synchronous boxes
       (boxes with a maximum size)

    Aside from these caveats, creating and using a threaded component is the
    same as a normal generator based one, except you simply don't have yield
    statements. You obviously use a different base class.

The use of the "ipc" message Axon.Ipc.newComponent for child component
startup has been deprecated in favour of the simpler API:

   X = SomeComponent()

Despite all these changes, components written for earlier versions of Axon
will continue to work as before.

Documentation has also generally improved,and is included in the the code
files for access via pydoc/help.

Message Passing and Delivery Optimisation Changes
  * Boxes are now discrete objects. This change has occured to enable the
    use of direct (effectively "zero copy" delivery).
  * This has meant the postman has been deleted - components no longer have
    a postman associated with them. This also dramatically frees up CPU
    cycles for components rather than the communications system.
  * To replace the structural tracking, a "postoffice" class has been
    created instead. This, however, is passive rather than active.
  * Because the death of a component no longer also means the death of a
    postman, microprocess has been simplified to remove the concept of
    activity creator. This removes the knock on complexity in both the
    scheduler and inside Component.
  * Despite these changes components running on top of Axon (ie existing
    Kamaelia components) operate largely unchanged. (A few that assumed the
    existance of a postman etc have changed)

Flow Control Inversion
  * The Scheduler therefore now dynamically builds its runqueue to only
    include unpaused (active) microprocesses.
  * If there are no active microprocesses, the scheduler can now sleep.
    Reducing CPU usage to zero, until some kind of event causes something to
    wake up. Flow of control is therefore effectively inverted as Axon
    systems can now be reactive.
  * Pausing state is now managed by the scheduler on behalf of
    microprocesses (they used to manage it themselves). Requests to wake and
    pause microprocesses get routed to the Scheduler.
  * The APIs for Component and Microprocess are, for the most part,
    unchanged. Existing components will continue to work as before. If they
    self pause they will benefit from reduced CPU usage. If all components
    in a system behave in this way, then Axon will cease to busy-wait when

Threading Support
  * The threaded component has had its API fixed to match the rest of Axon
    (with the obvious exception of removing the yields).
  * Threaded 'adaptive' component is new.

Detailed release notes & changelog:


Axon has been used successfully under both Linux, Windows and Mac OS
X (panther). This version of Axon has not yet been tested on series
60 mobiles.

Where can I get it?

Sourceforge Download:

Web pages are here:

Tutorial for the core component/concurrency system:

Axon Motivations:


Axon is a part of the Kamaelia project and as a result is released under
the Mozilla tri-license scheme (MPL1.1/GPL2.0/LGPL2.1). See

Best Regards,

Michael Sparks, Senior Research Engineer, BBC Research, Technology Group
michael.sparks at, Kamaelia Project Lead,

This message (and any attachments) may contain personal views
which are not the views of the BBC unless specifically stated. 

More information about the Python-list mailing list