What is NEOSIM?
Neosim is a framework to support large scale multi-level
modelling of the nervous system. It:
This early release of the Neosim development kit is intended
to help simulation software developers to start developing
modules for Neosim. It includes a Java discrete event simulation
kernel which can run on single processors, multiprocessors using
threading, and networked workstations using Remote Method Invocation,
Java's object oriented communications layer.
- allows plug-in of different simulation
components for simulation, visualisation and I/O.
- is specified in a way which allows running on workstations as
well as networks of workstations and parallel machines without
having to write a parallel program.
- is based on discrete event simulation.
A future development kit will be released with a higher performance
C++ simulation kernel, for pushing the limits of simulation scale
and speed. Currently Java optimising compilers can produce code
speeds comparable (and in some cases better than) optimised C and
Fortran code, but since C and C++ compiler technology is more mature,
it is still likely to have the edge over Java for the time being.
The Neosim kernel provides just the basic support necessary for building
and running large simulation models. All the interesting behaviour
of model components is provided by plug-in modules. These modules
are intended to be developed independently by different groups, and
can communicate with each other using the kernel interface. For example,
a model could be built using a visualisation component written in one lab,
a neuron simulation component from the NEURON simulator, another from
the GENESIS simulator and a number of home grown Java or C++ components.
When (and if) the time comes to scale up a model to more realistic sizes,
the neosim kernel will support the distribution of the model onto multiprocessors,
networked workstations or parallel machines without having to modify the
model description. This last point is crucial, as previous parallel
simulation tools (such as PGENESIS) required the model to become a parallel
program, with all the associated programming problems that entails.
This "transparent parallelism" is possible if the model is specified as
a number of entities which communicate using events. In fact there is an enormous
amount of available parallelism in a neuronal network model, since each
neuron is an independent computational unit which communicates using
spikes, and could theoretically run on its own processor. In practice
there is usually more parallelism available than needs to be exploited,
and parallel implementations partition a model to give some fraction of
the total number of neurons to each processor.
So, how is a model specified?
NEOSIM provides a number of basic classes which are extended
to provide particular behaviours.
- The ScriptReader class provides hook for the user to
provide a sequential control program. It acts as the main()
for a simulation, and issues commands to the kernel to make entities,
connect them, run and reset the simulation.
- An Entity is the superclass for all simulation
objects which change with time. An entity can send and receive
events via ports to other entities.
- An Event is the superclass for all timestamped objects
which get sent between entities. An event can be something
simple like a single spike, or a more complex object including
a large data structure and methods.
- A Population is a class for referring to an entire
set of entities at once, and for providing rapid lookup
of member entities.
- A Projection specifies a bundle of connections
between two populations of entities.
The place of XML in the framework
NEOSIM models can be built using a programming language such
as Java or C++ - or a script language using a script interpreter
module, and this is the way in which models have been constructed
in the past. For many modelling projects this is the most appropriate
technique, as it allows maximal flexibility. The price paid is that
it can be hard for people to reuse models described in this way,
as one has to understand someone else's code.
One way to encouraging reuse of models and components is to
use a declarative description format for the parts of models
which can be considered "data". Any ASCII format could be used
for this; XML is becoming increasingly popular as a format for
self-describing structured data. It is human-readable, essentially
like HTML with user-defined tags, and is becoming more important
as an interchange format between programs.
A major aim of this modelling framework is to allow anyone
to repeat a simulation model run given just an XML model file.
This currently works for models specified entirely using Java -
the XML file can pull in any additional code modules required
to run the simulation. For mixed C++/Java models the installation
is more involved and site-specific.
Last modified: Fri Nov 3 16:06:34 GMT 2000