Active Expressions - A Framework for Concurrency in C++
Mauricio De Simone (mdesimon@interlog.com)

-----------
Introduction


This is the initial alpha distribution of Active Expressions. The aim
of this library is to provide a library-based framework for concurrent
programming. No external tools, other than a template-capable c++
compiler, are necessary to instantiate concurrent type-safe programs.

This version is know to compile of Solaris 2.4 and 2.5 with Sun's CC
Version 3.0.1 or higher. An AIX version is also available that
compiles with the latest xlC compiler. Modify the Makefile to suit
your particular environment. 

Sorry, I have not been able to get gcc to compile Active Expressions,
although I wish I did!


----------
Tests

To compile the tests, modify the Makefile to reflect your
environment, and simply type:

make ./bin/simplepipe

If you compiled the program for shared memory machines (SHMEM=1) then
simply run this program and everything should work fine. If you are
interested in a distributed memory environment (DISTMEM=1) then thing
change a bit:

1.- It is your responsibility that each node get the binary in the
    local file system (a shared nfs directory works just fine
    too). 

2.- Create a procfile that reflects the topology of your
    network. Include the console machine first in the file. For example,
    if you have 3 machines (m1, m2, m3) in the domain "test.com", then
    the file will look like:

	m1.test.com
 	m2.test.com
	m3.test.com

    Note: Make sure that there are no leading, intermediates or
    trailing lines.

3.- Start all the servers first (that is all the nodes except you
    console node). To do that type:

	simplepipe -role server -port <portnumber>

    On nodes m2 and m3.


4.- Start the console node by typing:

	simplepipe -port <portnumber> -procfile <procfile>

    This will start everything up.


All these steps could be automated and is in my to-do list.


-----------
Examples

3 examples of applications written in Active Expressions have been
included. Maze, Popper and Swarm are full multi-threaded applications
that have been writing with minimal effort. These will probably not
be representatives of the applications where you might want to use AE,
but the show an interesting programming model.

Many thanks to Mark Frazer (mjfrazer@uwaterloo.ca) for his help on these.

To run the examples, simply go into the directory and type make.

-----------

Disclaimer: This code is alpha. It is a somewhat cleaner version of
the original Active Expressions code, but several issues are still
outstanding:

1.- The new terminology has not been yet included completely. "Active
    Components" were previously called "Worker Elements", and some
    areas of the library reflect this difference. Also, "Active
    Expressions" used to be called "data flow expressions", so you'll
    find places that refer to them as "dfe"s.

2.- The distributed memory version of the RTS does not terminate
    correctly. The program performs its functions, but the daemons
    don't shut down just yet.

3.- The syntax of the configurations file (debug.conf and procfile)
    is very rigid. No comments are allowed and the location of
    information in the file matters. Also, avoid trailing blank lines.

4.- There has not been a proper testing phase of this code, so expect
    some problems. All my preliminary tests work correctly, your
    mileage might vary.


Don't hesitate to contact me with any questions, comments or
contributions. Thanks for your interest!

Mauricio De Simone

(mdesimon@interlog.com)
