Workshop Summary

by Aiman Erbad and Mike Blackstock (please add your name here if you contribute!)

Experiences in Designing an Energy-Aware Middleware for Pervasive Computing

Authors

Abstract: Energy efficiency in pervasive computing is crucial for devices operated by battery. To provide energy efficiency we created an energy efficient middleware, called SANDMAN. It selects energy-efficient protocol stacks dynamically and switches idle devices in an energy-efficient sleep mode. In this paper we present an overview of the challenges we met when realizing this approach, possible solutions and lessons learned.

This paper extends BASE middleware to add energy efficiency leading to new middleware SANDMAN. Base is an extensible micro-broker that manages interaction with remote device. To communicate BASE uses plug-ins to support different communication technologies. SANDMAN is designed around two main concepts to save energy: First, it reduces energy by selecting the most energy-efficient communication protocol (uses BASE to choose the appropriate plug-in at runtime assuming each plug-in is annotated with energy consumption data). Second, it switches idle devices into low power sleep mode to reduce unnecessary stand-by energy consumption. To do so, SANDMAN clusters devices dynamically depending on their mobility patterns and neighbouring devices. This allows to deactivate devices while preserving the network connectivity and the discovery of the devices.

Challenges include:

• Transition scheduling
  • Use fixed inactivity threshold
  • Explicitly specify which devices are in use
  • Added session so a client can specify it is using a device service
• Discovery
  • Use clustering to have one node (cluster head) with required information to discover nodes in the cluster
• Connectivity preservation
  • Put the responsibility of routing on cluster heads
• Interaction latency
  • A client wanting to use a sleeping device must wait until the device awakes on its own. Therefore, we cooperatively schedule sleep time of all devices in a cluster (e.g. make sure devices with similar services don’t all sleep simultaneously)

MAGIC Broker: A Middleware Toolkit for Interactive Public Displays

by Aiman Erbad, Michael Blackstock, Adrian Friday, Rodger Lea, Jalal Al-Muhtadi

Abstract:

Summary

Discussion

Middleware Service for Multimodal Interactions in Smart Environments

Abstract: Smart and intelligent environments can proficiently benefit from a new generation of multimodal dialog systems, which enable users to interact in natural ways like voice, gesture, facial motions, and so on. However, in order to make this possible, it is necessary to integrate such systems and services, possibly in a transparent way. In the present paper, we propose i) an architectural model for multimodal smart environments; ii) an agent-based middleware infrastructure that provides basic components for the integration of multimodal interaction systems; and, iii) a tool for rapid-prototyping, which automatically customizes some middleware components to implement multimodal interaction mechanisms for the environment’s application services.

Classic desktop metaphor based on GUI interfaces can not constitute the main way to access services in pervasive computing environments. More natural interfaces, such as gesture, voice, and facial expression are better ways to interacts.

The main contribution is an architecture and middleware infrastructure for multimodal dialog interactions in smart environments (through mono-modal interaction channels). Architecture has three layers: interface layer (have adapters that interact with different interaction devices), flow handler layer (handle interaction state machine and evolve as interaction arrive from lower layer), and application layer.

Multimodal architecture relies on parallel state machine each application has it own interface state machine. Conflicts are resolved by the user and a context reasoned is used to alleviate conflicts.

The current prototype has three interfaces: classic GUIs, voice commands, and environment speech synthesis. It is developed using the SRI’s open agent architecture. PGen is a supporting tool for rapid prototyping that has been developed to generate code for the Flows Handler.

Enabling Deliberate Design for Energy Management in Pervasive Systems

Authors

Abstract: This paper argues for explicit consideration of data fidelity during development of context-aware systems. Increasing the amount of data captured, stored, and distributed does not always translate into increased fidelity, and we can leverage this to avoid unnecessary energy overhead and increase device battery life. We introduce Context-Awareness Fidelity Expression (CAFE) as a framework for deliberately specifying application data fidelity adaptation with the aim of using context-awareness to reduce energy consumption.

This paper proposes the use of context fidelity, meaning the accuracy of the representation of true context to reduce energy consumption. Context data fidelity is the level of representation provided by context data with respect to truth reference. Therefore, it is an error metric between context data and defined reference. The paper discusses context data fidelity in three dimensions: capture, storage, and distribution. Reducing fidelity has traditionally been viewed as a way to reduce energy consumption (since low fidelity is believed to require less work). This paper argues that for context-aware applications increased amounts of data capture, storage, and distribution does not necessarily increase data fidelity but it might reduce fidelity.

CAFÉ is a framework for reasoning about data fidelity as it relates to the amount of data captured, stored, and distributed in context-aware systems. CAFÉ defines a context type which affect the behavior of the system and the context states that determine the defined reference by which fidelity is measured. Then, it gets the context sources available and perform a pairing step which matches context types with context sources. Finally, for each pairing a context value specification is created to reflect the data fidelity. CAFÉ provides a procedural interface through a set of Java object called CAFÉ Enablement Environment to help developers incorporate data fidelity into their applications.

Safety Enhancing Mechanisms for Pervasive Computing Systems in Intelligent Environments

Authors

Abstract: Pervasive computing systems provide personalized and intimate services to improve users’ quality of life by integrating computation and communication into the environments. With the capability to interact with the physical world and the promise in assisting or managing aspects of users’ daily lives, the requirement for safety is high and imminent. The difficulty in providing safety is the result of the dynamicity, complexity, heterogeneity and uncertainly typical in pervasive computing. After examining and analyzing worst-case scenarios of safety violation, we identify four fundamental elements whose individual safety assurances add greatly to the overall system safety. We propose safety enhancing mechanisms for each of the four elements and their interactions.

The talk started by defining safety in pervasive computing environment. Safety is the condition of being safe from undergoing or causing hurt, injury or loss. The author argues that safety is as important as effectiveness or usability. Safety scenarios include: conflicting usage of shared resources, invalid operational directives, risk of conflicting side effects, and violation of user centric computing. Safety is collaborative effort between middleware at run time and the programming aid at implementation time. Existing safety mechanisms that can be utilized for pervasive computing systems include:

• Physical safety
• Safety mechanisms for computer systems, such as authentication, and access control
• Exiting robustness and availability enhancing mechanisms

Four fundamental elements of pervasive computing systems are devices, services, users, and spaces. A description of these entities, such as device description, service interface and state, user profile, space state (using ontology) is required to enforce safety enhancing mechanisms.

Safety mechanisms for pervasive computing systems:

1. Static safety mechanisms priority safety API
   1. State machine and service safety API
   2. Mandatory power down sequence for all services
   3. Primitive methods with priority
2. Dynamic safety mechanisms in the middleware
   1. Device safety checker
   2. Context manager and event detector
   3. Emergency handler vector
   4. Service registery

The proposed mechanisms provide basic safety protection against abuse of devices and services, ensure explicit user profile alignment, and use impermissible contexts as the second line of defence against safety risks not explicitly tied to any particular service or device.

A Trust-based Middleware for Providing Security to Ad-Hoc Peer-to-Peer Application

Abstract: Trust has emerged as an important facet of inter-domain relationships. Trust management in fixed networks is not functional in ad hoc P2P networks, because these require an autonomous, user-centric and non-static trust management. The trust model is the basis of any security infrastructure. In this paper, we propose a trust-based middleware for secure digital content sharing between pervasive devices. Such middleware allows to enhance security support of pervasive devices. Likewise, we propose a suitable and efficient secure file exchange protocol, WSFEP, for content sharing. Both middleware and file sharing application have been successfully integrated and tested on PDAs.

Summary: This paper provides a trust-based middleware for secure digital content sharing between pervasive devices in a dynamic P2P environment. The paper proposes a new protocol for secure file exchange, WSFEP (Wireless and Secure File Exchange Protocol) which establishes the importance of trust management as basis of security and management in peer-to-peer applications.

The trust layer based on Pervasive Trust Management model establishes trust between secure peer in ad hoc way. We measure the entity’s trustworthiness through its actions using multi-valued fuzzy logic to express the trust relationships. The trust layer consists of a trust manager, security layer, and access control module.

Trust management in previous work assumes “one user, one device”. However, in pervasive computing we have a vision of “one user, multiple devices”. Therefore, information about trust in managed in all the user’s devices.

A survey of Current Directions in Service Placement in Mobile Ad-Hoc Networks

Abstract: Service placement deals with the problem of selecting which node in a network is most suitable for hosting a service that responds to queries from other nodes. Optimally placing services reduces network traffic and improves connectivity between clients and servers. Service placement algorithms may thus be regarded as an interesting building block for research into service-oriented middleware. Recently, new approaches to address the service placement problem in the field of ad-hoc networking have been proposed. This paper surveys, classifies and evaluates ten representative approaches, thereby providing a summary of the state of the art in service placement.

Summary: The main question this paper addresses is how much how far the performance of the network can be increased by intelligently selecting which nodes are to host a particular service. The main contributions of this paper are to survey recent approaches of service placement in MANETs, and to classify and evaluate these approaches. The key questions to be answered are: 1) Where in the network are services or service instances of a distributed service to be placed? 2) How many service instances are required for cost optimal operation? 3) When should the current configuration of service and service instances be adapted? 4) How are services and their state to be transferred from one node to another? (mobile agents) A service is a software component executed on one or several nodes of the network. Service properties to narrow down the broad view on services include: 1) Node-specific Vs node independent 2) Centralized Vs distributed 3) Composite Vs monolithic 4) Message-based Vs streaming Evaluation criteria for service placement algorithms include: Service demand: service requests over a period of time Service Provision Cost: is the cost incurred while service requests are served over time. Control traffic overhead: additional control information that algorithms may require nodes to exchange Theoretical Background The paper shows the similarities of service placement to facility location problems, such as k-median problem and the facility location problem. The paper survey different service placement algorithms which are classified based on and concludes these common prototypical mechanisms are widely employed: • Passive monitoring: Information is extracted from service-related network traffic. • Piggybacking: Information is sent together with service-related network traffic. • Limited broadcasts: Information is sent to all nodes in a bounded. • Iterative limited broadcasts: the broadcast process is repeated several times. • Iterative unlimited broadcasts: Information is repeatedly sent to all nodes in the network.

As for state of the art the survey concludes that current approaches answer the first two questions (where and how many), the third question (when) has not been addressed in depth. Moreover, the interactions between service placement and existing service discovery and routing protocols are also unexplored.

An Adapter Chaining Scheme for Service Continuity in Ubiquitous Environments with Adapter Evaluation

Abstract: A key feature of ubiquitous computing is service continuity which allows a user to transparently continue his task regardless of his movement. For service continuity, the underlying system needs to not only discover a service satisfying a user’s request, but also provide an interface differences resolution scheme if the interface of the service found is not the same as that of the service requested. For resolving interface mismatches, one of solutions is to use an interface adapter. The most serious problem in the interface adapter-based approach is the overhead of adapter generation. There are many research efforts about adapter generation load reduction and this paper focuses on an adapter chaining scheme to reduce the number of necessary adapters among different service interfaces. We propose a construction-time adaptation loss evaluation scheme and an adapter chain construction algorithm, which finds an adapter chain with minimal adaptation loss.

Summary: This paper proposes an adapter chain construction algorithm using a construction-time adaptation loss evaluation scheme to find the chain with minimal adaptation loss. A matrix-based model is used to evaluate an adapter chain loss. A method dependency matrix specifies dependency relationship between methods of an interface and method mapping matrix represents the mapping of method between two interfaces. The degree of adaptation loss of an adapter is the ratio of supported methods to the total number of methods in the required interface. The adapter chain construction algorithm is a modification of the uniform cost search algorithm.

Design of Software Architecture for Smart Meeting Space

Abstract: This paper introduces the software design for smart meeting space (SMeet) that enables users to collaborate with remote persons by using a wide range of devices embedded in networked meeting rooms. To enhance the quality of user experience in remote collaboration, SMeet is designed to satisfy several considerations from the integrated view of media, networking, display, and interaction services. We propose a software architecture of SMeet to flexibly associate component services to support high-quality media transport, high-resolution tiled display, and display interaction. We also present an approach to create composite services by combining component services. We explain key issues to dynamically build composite services and to integrate the service composition scheme with the proposed software architecture.

Summary: This paper focuses on the interaction among remote users and introduces the smart meeting space (SMeet), which is a ubiquitous environment for collaboration. The paper main contribution is a software architecture of SMeet and an approach of using service composition to construct flexible SMeet nodes to satisfy dynamic service requirements of users. The two main requirement of SMeet are: 1) User-centric collaboration using context sharing 2) Flexible organization of meeting space components and composite services.

The software architecture has three layers: 1) Task layer 2) Service manager layer (SMeet mediator) 3) Service composition layer ??

The major contributions of this paper are summarized as follows. First, we clarify what is the level of services that divides a component service and a composite service and present some examples of them in SMeet. Second, we initially design a service composition procedure to combine multiple component services for constructing complex collaboration service. Finally, we demonstrate the feasibility of the proposed composition scheme by constructing a prototype system.

Some discussion questions: 1) Did you try using your middleware with real developers? 2) Should I change my application to work with your middleware? (are you using a common standard)

Panel Discussion

The topic of the panel was "Free well in pervasive computing: Balancing autonomy and user control".

The panelists:

One panelist had the opinion that we need to use thresholds to transition from autonomous behavior to user controlled behavior. Another panelist had the opinion that systems/applications should know what the user want and simply work. Systems should also evolve to accommodate user preferences. Another panelist emphasized that our job as systems designers is to present easy to program abstractions for application developers. It is the application designer's job to balance user control with autonomy of the application itself.

During the discussion there seemed to be some confusion about what do we mean by "free will" and what does it mean to balance between autonomy and user control. A good point was raised that autonomy does not always imply lack of user control. A user can issue a command and have full control while the infrastructure can be autonomous and smart about the best way to perform the task.

Another similar point is that users don't really need to understand the details of a task and they can just delegate it to an entity which can be autonomous in performing the task. The example, there are programming libraries and packages that we use in our systems without understanding how they do their job, just that they accomplish the task such as sorting.