Limone

A lightweight coordination middleware for wireless ad hoc networks.

Abstract

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.

People

  1. Gruia-Catalin Roman
  2. Chien-Liang Fok
  3. Gregory Hackmann

Publications

Conferences

  1. Fok, C.-L., Roman, G.-C., and Hackmann, G., “A Lightweight Coordination Middleware for Mobile Computing,” Proceedings of the 6th International Conference on Coordination Models and Languages (Coordination 2004), De Nicola, R., Ferrari, G., and Meredith, G., (editors), Lecture Notes in Computer Science 2949, Springer-Verlag, Pisa, Italy, February 2004, pp. 135-151.

Implementation

Core Middleware

Click here to download the core Limone middleware. To use it, simply extract the zip to a local directory and type "make". This will create a limone.jar file in <install dir>/jars, which can then be used by your application.

Applications

Three applications have been written using Limone. They include a Chat program, Boggle game, and Universal Remote Control. Download them here:

  1. Chat
  2. Boggle
  3. Universal Remote Control

Related Work

  1. Bogdan Carbunar, Marco Tulio Valente, Jan Vitek, "Coordination and Mobility in CoreLime" Journal of "Mathematical Structures in Computer Science" (MSCS), 14(3), June 2004
  2. Bogdan Carbunar, Marco Tulio Valente, Jan Vitek, "CoreLime: A Coordination Model for Mobile Agents". ConCoord: Workshop on Concurency and Coordination, Lipari, July 6-8, 2001
  3. Bogdan Carbunar, Marco Tulio Valente, Jan Vitek, " Lime Revisited: Reverse Engineering An Agent Communication Model". In Proceedings of MA2001, Atlanta, December 2-4, 2001

This work is supported by the ONR MURI Project CONTESSA and the NSF under grant number CCR-9970939.