Evaluation of error control mechanisms for 802.11b multicast transmissions

This article first presents several packet loss profiles collected during 802.11b multicast transmissions carried out under variable reception conditions (mobile and fixed receivers). Then, an original approach consisting in mapping a posteriori some error control mechanisms over these observations is presented. This approach allows to evaluate the performance of these mechanisms according to their parameters and various channel properties. It is shown in particular that relatively simple mechanisms based on retransmissions and/or error correcting codes of small length achieve very good performance in this context (92% of the best performance)

FRIENDS - A flexible architecture for implementing fault tolerant and secure distributed applications

FRIENDS is a software-based architecture for implementing fault-tolerant and, to some extent, secure applications. This architecture is composed of sub-systems and libraries of metaobjects. Transparency and separation of concerns is provided not only to the application programmer but also to the programmers implementing metaobjects for fault tolerance, secure communication and distribution. Common services required for implementing metaobjects are provided by the sub-systems. Metaobjects are implemented using object-oriented techniques and can be reused and customised according to the application needs, the operational environment and its related fault assumptions. Flexibility is increased by a recursive use of metaobjects. Examples and experiments are also described

A metaobject architecture for fault-tolerant distributed systems : the FRIENDS approach

The FRIENDS system developed at LAAS-CNRS is a metalevel architecture providing libraries of metaobjects for fault tolerance, secure communication, and group-based distributed applications. The use of metaobjects provides a nice separation of concerns between mechanisms and applications. Metaobjects can be used transparently by applications and can be composed according to the needs of a given application, a given architecture, and its underlying properties. In FRIENDS, metaobjects are used recursively to add new properties to applications. They are designed using an object oriented design method and implemented on top of basic system services. This paper describes the FRIENDS software-based architecture, the object-oriented development of metaobjects, the experiments that we have done, and summarizes the advantages and drawbacks of a metaobject approach for building fault-tolerant system

An opportunistic indoors positioning scheme based on estimated positions

The localization requirements for mobile nodes in wireless (sensor) networks are increasing. However, most research works are based on range measurements between nodes which are often oversensitive to the measurement error. In this paper we propose a location estimation scheme based on moving nodes that opportunistically exchange known positions. The user couples a linear matrix inequality (LMI) method with a barycenter computation to estimate its position. Simulations have shown that the accuracy of the estimation increases when the number of known positions increases, the radio range decreases and the node speeds increase. The proposed method only depends on a maximum RSS threshold to take into account a known position, which makes it robust and easy to implement. To obtain an accuracy of 1 meter, a user may have to wait at the same position for 5 minutes, with 8 pedestrians moving within range on average

Fragmentation of confidential objects for data processing security in distributed systems

This paper discusses how object orientation in application design enables confidentiality aspects to be handled more easily than in conventional approaches. The idea, based on object fragmentation at design time, is to reduce processing in confidential objects; the more non confidential objects can be produced at design-time, the more application objects can be processed on untrusted shared computers. Still confidential objects must be processed on non shared trusted workstations. Rules and limits of object fragmentation are discussed together with some criteria evaluating trade-offs between fragmentation and performance

When should I use network emulation ?

The design and development of a complex system requires an adequate methodology and efficient instrumental support in order to early detect and correct anomalies in the functional and non-functional properties of the tested protocols. Among the various tools used to provide experimental support for such developments, network emulation relies on real-time production of impairments on real traffic according to a communication model, either realistically or not. This paper aims at simply presenting to newcomers in network emulation (students, engineers, ...) basic principles and practices illustrated with a few commonly used tools. The motivation behind is to fill a gap in terms of introductory and pragmatic papers in this domain. The study particularly considers centralized approaches, allowing cheap and easy implementation in the context of research labs or industrial developments. In addition, an architectural model for emulation systems is proposed, defining three complementary levels, namely hardware, impairment and model levels. With the help of this architectural framework, various existing tools are situated and described. Various approaches for modeling the emulation actions are studied, such as impairment-based scenarios and virtual architectures, real-time discrete simulation and trace-based systems. Those modeling approaches are described and compared in terms of services and we study their ability to respond to various designer needs to assess when emulation is needed

A feedback based solution to emulate hidden terminals in wireless networks

Mobile wireless emulation allows the test of real applications and transport protocols over a wired network mimicking the behavior of a mobile wireless network (nodes mobility, radio signal propagation and specific communication protocols). Two-stage IP-level network emulation consists in using a dedicated offline simulation stage to compute an IPlevel emulation scenario, which is played subsequently in the emulation stage. While this type of emulation allows the use of accurate computation models together with a large number of nodes, it currently does not allow to deal with dynamic changes of the real traffic. This lack of reactivity makes it impossible to emulate specific wireless behaviors such as hidden terminals in a realistic way. In this paper we address the need to take into account the real traffic during the emulation stage and we introduce a feedback mechanism. During the simulation several emulation scenarios are computed, each scenario corresponding to alternative traffic conditions related to e.g. occurrence or not of hidden terminals. During the emulation stage, the traffic is observed and the currently played emulation scenario can be changed according to specific network conditions. We propose a solution based on multiple scenarios generation, traffic observers and a feedback mechanism to add a trafficbased dynamic behavior to a two-stage emulation platform. The solution will be illustrated with a simple experiment based on hidden terminals

Using Triggers for Emulation of Opportunistic Networking

Opportunistic networks do not require the availability of an end-to-end path, but may instead take advantage of tem- porary connectivity opportunities. Opportunistic networks pose a challenge for network emulation as the traditional em- ulation setup where application/transport endpoints send/ receive packets from the network following a black box approach is no longer applicable. Instead opportunistic networking protocols and applications need to react to the dynamics of the underlying network beyond what is conveyed through the exchange of packets. In order to support emulation evaluations for such challenging applications we in this paper introduce the concept of emulation triggers that can emulate arbitrary cross-layer feedback and that are synchronized with the emulated scenario. The design and implementation of triggers in the KauNet emulator are described. The use of triggers in the context of opportunistic networking is brie y sketched