[Date Prev] [Date Next] [Thread Prev] [Thread Next] Date Index Thread Index Search archive:
Date:Tue, 24 Feb 2004 18:58:18 +0000 (UTC) 
Subject:References on Poplog Concurrency? 
From:A . Sloman 
Volume-ID: 

Brent

> I'm a Poplog novice, trying to understand the available features of the
> current implementation.

It's a huge task as there is so much of it. Since almost all of it is
implemented in pop11 you'll need to learn pop11 if you dont know it.
You can pick up a subset from the primer:

    http://www.cs.bham.ac.uk/research/poplog/primer/START.html

I you have fetched the bham-linux-tar.gz file you'll find a gzipped
tar file containing that. It is almost the same as the TEACH primer
file $usepop/pop/teach/primer -- a flat text file.

> I'm curious if there is a description of Poplogs support for concurrency
> and distributed computing (e.g., is it easy to spread a problem across
> multiple machine nodes in the fashion of Mozart/Oz or Erlang)?

As far as concurrency is concerned there are many approaches to this.

You can spawn multiple poplog processes and have them communicate via
sockets or pipes (on the same machine). Useful if you have a multi-cpu
machine for instance.

You can also do concurrency within a machine running in a single unix
(or vms) process.

There are at least two very different ways of doing this

 1. Use the pop11 process package
    See
        HELP process
        REF process

        HELP actor
            Shows how to use the process mechanism to implement a
            discrete event package, without preemptive scheduling.
            This can be used for a simple form of pseudo concurrency,
            insofar as each actor exists over a time period doing
            whatever it has to do. (Uses co-routines which explicitly
            hand over control.)

    http://www.cs.bham.ac.uk/research/poplog/teach/opsys
        This teach file from Sussex, not included with poplog,
        illustrates the use of processes and the timer to implement
        a very simple simulated operating system, with preemptive
        scheduling.

2. Develop your own language for expressing threads and an interpreter
for it which is able to switch between threads.

    This requires you to ensure that each thread has its own state saved
    when control switches to another thread. This is the approach taken by
    the SimAgent package, where each thread is essentially an run of the
    poprulebase interpreter, except that a single run can manage multiple
    threads. Each agent can contain multiple rulesets which are run pseudo
    concurrently. Likewise each agent or object can be thought of as a
    coarser thread and a collection of them can be run concurrently, so that
    we get agents running (pseudo-)concurrently with each other and within
    each agent the various internal mechanisms run (pseudo-concurrently). To
    use this you have to learn to program in a style which makes every
    process constantly 'checkpoint' its state so that others can have a turn
    to run. There is more on SimAgent in these two
        http://www.cs.bham.ac.uk/research/poplog/packages/simagent.html
        http://www.cs.bham.ac.uk/research/cogaff/talks/#simagent

    Example applications are shown in movies here:
        http://www.cs.bham.ac.uk/research/poplog/figs/simagent/

================

If you want 'real' concurrency with processes distributed across various
physical machines then you can build your own way of doing that as many
others have by running pop11 (or other poplog) processes on various
machines which communicate via sockets, or possibly even via nfs-mounted
disks!

Brian Logan at Nottingham University with collaborators in Birmingham
has been working on an EPSRC funded project to design a more
'principled' way of distributing SimAgent. Papers are available
here:
    http://www.cs.nott.ac.uk/cgi-bin/bsl/papers.cgi
The project home page is
    http://www.cs.bham.ac.uk/research/pdesmas/

(Beware: network connections to cs.bham are very flaky at present, for
unknown reasons.)

> Could someone please point me towards any references on this topic?

You may be able to get more help if you say precisely what you want to
do as there are many kinds of concurrent systems with very different
requirements.

> in the fashion of Mozart/Oz or Erlang)?

I don't know much about these systems but I suspect that they tend to be
aimed at supporting so called 'multi-agent' research and development,
involvign large numbers of relatively simple homogeneous processes using
relatively simple forms of interaction distributed over multiple
machines, with lots of built-in support for use of internet mechanisms
(web addresses, email, etc.)

SimAgent is primarily directed at people wishing to explore
architectures where individual agents each of which is very complex with
multiple components of different sorts interacting in many different
ways including some of them observing the internal behaviour of others,
and including a lot of support for self-observation and
self-modification.

If what you want to do fits Mozart well it will probably give you better
support than Poplog/SimAgent. If your needs are not well defined and you
want to explore a variety of different sorts of inhomogeneous
architectures you may find the flexibility of simagent preferable, along
with the debugging advantages of an implementation based on an AI
language with incremental compiler.

I hope that helps.

[For some reason the Mail->News gateway stopped working today and your
message did not get forwarded to comp.lang.pop. I have now forwarded it.
The software may have been confused because you addressed your message
both to me and to pop-forum, which is redundant.]

Aaron
--
Aaron Sloman, ( http://www.cs.bham.ac.uk/~axs/ )
School of Computer Science, The University of Birmingham, B15 2TT, UK
EMAIL   A.Sloman@cs.bham.ac.uk
PAPERS: http://www.cs.bham.ac.uk/research/cogaff/
FREE TOOLS: http://www.cs.bham.ac.uk/research/poplog/freepoplog.html
TALKS: http://www.cs.bham.ac.uk/~axs/misc/talks/
FREE BOOK: http://www.cs.bham.ac.uk/research/cogaff/crp/