For a general presentation of the project, please visit the homepage of the project.
The Assasim project is organized in multiple parts, namely the precompilation, the simulation, the interface and the language.
The goal of the language part is to create a high-level modelling language that can be used by someone with little to no programming knowledge. This language can be used to describe models that our tool will analyse and build upon. The language part outputs C++ code describing the whole simulation following the syntax defined by the precompilation. A user with knowledge of C++ is also able to develop its own models if he follows the same syntax (e.g. inheriting a certain class that describes an agent or interactions).
The precompilation part is divided in two main steps. The first one is taking as an input C++ code from the users or from the language part, and creating a development environment that will host the modelization. The second step takes the behaviour of all the agents of the simulation and bundle them together to create binaries. Both steps check the interactions, behaviour, attributes of the agents for inconsistencies in the modelization.
The simulation block is the one managing the communications between the distributed nodes that are used to run the simulation. It manages the information exchange between agents, the migration of agents accross the distributed system, and the access to remote ressources.
Finally, the goal of the interface is to provide the user a high-level visualisation of the results of the simulation as well as a basic control of its behaviour.
The precompilation code heavily uses lib clang to parse and analyse the C++ code provided by the language or the user. Most of the work of the precompilation is building an intermediate representation of the model (also used by the interface part), listing agent attributes and interactions, and checking the soundness of the model up to a certain level.
The core of the simulation uses the last standard of the Message Passing Interface (Version 3.1) to exchange data between the distributed parts that make up our tool. The selected architecture is a master-slave one, with each physical node (shelf computer or server) having its own master coordinating multiple threads that executes the behaviours of the agents. The communication inside one physical node is done using shared memory. Accross physical nodes, remote direct memory access is used to query the state of simulation and exchange simulation data as well as metadata.
We use the Qt library (version 5) to design the interface. We have one main window that can contain one of the following windows: - Model Tool Window: It let the user open a json representation of a model and choose the first values of the different variables of the model. (in develepement) Create a description using a tree of the model and have a text editor to write, open, precompile a model. - Instantiation (coming soon) : theoretically a window that specializes for the instantiation of a model opened in the json form (for now we do it in the Model Tool Window) - Simulation Window: It allows the user to run and stop the simulation. To read a value, it reads json formatted data that the simulation sends at every tick of time. It also contains graphs to analyze the current simulation.
The language aimed to be as intuitive as possible. It is very close to natural language and should looks friendly even to those who are not fluent in C++. The language looks like a classic imperative one providing specific features allowing to handle easily agent definition, communication by messages between agents and agent creation and destruction.
The simulation should be be described in two main steps to take advantage from the structure of the language:
First step: defining messages for all the agents
Second step: defining the agents themselves. An agent has three parts to be implement:
the state part which contains the definitions of all variables of the agent.
the filter part which handles the messages and then modifies the states.
the behavior part which implements the different actions of the agent reacting to messages.
The language is then translated in C++ so an advanced user can choose to directly code in C++ using the Assasim framework. One can also write program with the language and switch to C++ at any time.