wiki:SIMEO

SIMEO: SIMulation architecture for the study of Emergence and auto-Organization

  • Team members: Octavian Voicu - voicu.octavian, Bogdan Ghit - ghit.bogdan, Andrei Ciortea - andrei.ciortea
  • Project description: design of a framework for studying the interactions between large numbers of agents in a simulated virtual world.

Technologies

Tools

  • KDevelop
  • Cmake
  • Git

Abstract

The goal of SIMEO is to offer a generic framework designed to facilitate the study of interactions between large numbers of agents in a simulated virtual world. The environment of this virtual world is composed of many objects that may execute different physical interactions between themselves, each of them being controlled by an agent. An agent monitors the environment through sensors and applies impulses in the world through actuators. Our aim to create a framework with large applicability that can have a major impact in the study of emergent and self-organization systems. In order to reach the ability of self-organization, agents should also be able to communicate with each others directly, through messages.

Framework Specifications

  1. Define system components:


The system's architecture is based on the standards provided by FIPA (Foundation for Intelligent Physical Agents) from which are inspired many of the current agents platforms. We present below the components proposed for our system and a brief description:

  • MAIN CONTROLLER - manages the other controllers + load balancing
    • creates controller for each environment zone
    • allows agents to join platform
    • ensures communication with the environment
  • CONTROLLERS - facilitate efficient communication between other entities living in the same zone
    • establishes virtual communication channels
    • relays percepts from environment to sensors
    • relays commands from actuators to environments
  • SERVICES
    • assign global unique identifiers per agent
    • discover other accesible agents
    • join / part communication channels
    • roaming service for agents migration
  • AGENTS
    • SENSORS - monitor the environment
    • ACTUATORS - apply changes to the environment
    • CHANNELS - allow agents to communicate

As during this semester activity we wanted to keep focused over the parallelism issues and communication models, the current implementation does not offer support for load balancing through controllers.

The main controller will be responsible for adding agents to the platform and for establishing virtual communication channels. It also relays percepts from environment to sensors and commands from actuators to environment.

On the other hand, the agent contains sensors that will continuously monitor the environment, actuators that will apply changes to the environment and also channels that will allow the communication between different agents.

  1. Specify communication mechanism
  • MAIN CONTROLLER <-> ENVIRONMENT
  • MAIN CONTROLLER <-> CONTROLLER
  • CONTROLLER <-> AGENTS

Bullet Infrastructure

The framework is developed on top of Bullet, a professional open source physics engine. It's main task is to perform collision detection, resolve collisions and other constraints and provide the updated world transform for all the objects in the simulation.

Bullet has been designed to be customizable and modular. The developer can

  • use only the collision detection component
  • use the rigid body dynamics component without soft body dynamics component
  • use only small parts of a the library and extend the library in many ways
  • choose to use a single precision or double precision version of the library
  • use a custom memory allocator, hook up own performance profiler or debug drawer

The main components are organized as follows:

Bullet Components

SIMEO Architecture

The system is formed of two major components, the SIMEO Engine and the SIMEO GUI, as shown in the following figure:

Simeo Architecture

The Master is responsible with running the environment simulation, creating the agents / workers and launching the the GUI.

Each slave thread runs an agent which interacts with the environment through sensors and actuators. The sensors are the ones notifying the agent of changes in the environment, while the actuators, after being updated by the agent to reflect the action it wants to take, act on the environment.

Each sensor / actuator is coordinated by a provider which represents its correspondent in the master thread. The provider is the component executed by the master and will update the sensor (respectively, it will receive the action wanted by the agent). The master communicates with the agents through channels created between the sensors / actuators and their associated providers.

The master thread will first set up the simulation by creating the environment, waiting for all agents to register and creating the channels of communication with these agents. Also, the master sends to each agent the information necessary for gaining access to the corresponding channels and for creating the sensors and the actuators. For each step of the simulation, the master will first update all sensor providers, which send the new data to the agents. The master will wait for the agents' responses. The received actuators will then be applied on the environment. The changes made to the environment are sent to the GUI.

The Engine contains a component to which we will refer as the remote GUI. This is the component that communicates with the GUI, by sending all the environment data necessary for drawing a frame, like the object positions, etc.

Implementation

SIMEO framework was implemented in C++ with the requirement of being extensible and the virtual world environment was simulated using the Bullet Physics Library. Channel implementation was realized with OpenMPI, while the Remote Gui protocol is TCP based. Agents provide support for Sensors, Actuators and Communication Channels and can be implemented both in C++ and Java.

Testing

Our killer application is a 2D structure composed of a set of spheres connected through bars with 2-degrees of freedom constraints as shown in the images below:

Hinge Constraint

Each agent controls a sphere and uses sensors and actuators to interact with the environment for monitoring constraints. The simulation shows a network of agents moving on a path described by the sinus function, fact which gave it the name "The Lazy Worm".

Simeo GUI and the Lazy Worm

Project activity

  • Dec 13th
    • C++/Java interaction: details
    • MPI tests: details
    • finished proof of concept code for a "magic carpet" controlled by agents, and a 3D blob-like structure
  • Nov 26th
    • started work on a proof of concept sensor/actuator demo
    • started work on a remote gui
    • set up compile environment on Cell
    • compiled Bullet library on Cell
  • Nov 23th - renamed project + compiled lib on cluster
  • Nov 19th - compiled and tested the Bullet library
    • compliling Bullet Physics Engine: details
Last modified 12 years ago Last modified on Jan 19, 2010, 4:53:17 PM

Attachments (7)

Download all attachments as: .zip