Mobile devices like uptra-portable laptops, PDA, cellphone, etc., support ad hoc networking where they communicates directly with each other based on wireless range. Ad hoc networks provide many inherent benefits to traditional networks, the foremost being they do not require any infrastructure and, thus, can be rapidly deployed. Yet, ad hoc networks are rarely used because they are difficult to configure and few applications can deal with a dynamic environment where communication links randomly form and break based on proximity. This motivates the need for coordination middleware capable of abstracting the complexities associated with ad hoc mobility into a clean model.
Several coordination middlewares like LIME, EgoSpaces, PeerWare, MARS, and JEDI have been developed to simplify ad hoc application development. These projects, however assume the a relatively stable, or at least predictable, network and plenty of computational resources like processor speed, memory, and network bandwidth. They provide powerful operations like a federated tuplespace and high levels of atomicity that adds an undue amount of transactional overhead. Many mobile devices like cell phone, PDA, and ultraportable laptops do not posses the resources needed by these middleware. Furthermore, the ad hoc network often does not meet the required level of predictability, resulting in unpredictable application behavior. To address this problem, we developed Limone that builds upon the models provided by the aformentioned middleware, but tailors the primitives to ensure lightweightness and minimize assumptions, making it usable in practical day-to-day wireless ad hoc networks.
Limone is a lightweight coordination model that facilitates rapid application development over ad hoc networks consisting of logically mobile agents and physically mobile hosts. Limone assumes an agent-centric perspective on coordination by allowing each agent to define its own acquaintance policy and by limiting all agent-initiated interactions to agents that satisfy the policy. Agents that satisfy this acquaintance policy are stored in an acquaintance list, which is automatically maintained by the system. This asymmetric style of coordination allows each agent to focus on relevant peers. Coordination activities are restricted to tuple spaces owned by agents in the acquaintance list. Limone tailors Linda-like primitives for mobile environments by eliminating remote blocking and complex group operations. It also provides timeouts for all distributed operations and reactions that enable asynchronous communication with agents in the acquaintance list. Finally, Limone minimizes the granularity of atomic operations and the set of assumptions about the environment.
Limone's model is shown below:
Each mobile host supports numerous agents, each of which maintains their own tuplespace. The tuplespaces ensure each agent is autonomous by decoupling agent interactions in both time (e.g., one agent inserts a tuple, an other later picks it up) and space (e.g., one agent inserts a tuple, moves away, another picks it up). This decoupling between agent interactions ensure applications do not break when ad hoc communication links change. To facilitate agent execution, Limone creates a profile for each agent that is periodically advertised. Each agent uses these profiles to discover neighboring agents and to determine which neighbors are relevant. For each agent, the application developer tells Limone which agents he considers relevant, and Limone automatically filters the context to only relevent agents.
Mobile agents can migrate from one node to another. For now, only weak migration is supported. In a weak migration, only the agent instruction is transferred. Upon arrival at the destination, it is restarted at the beginning.
Three applications have been written using Limone. They include a Chat program, Boggle game, and Universal Remote Control. Download them here: