To harness the potential of edge resources, two-tier client-cloud applications require transformation into three-tier client-edge-cloud applications. Such transformations are hard for programmers to perform correctly by hand. Many cloud services maintain a runtime state that needs to be replicated at the edge. Once replicated, this state must then be synchronized efficiently and correctly. To facilitate the transition to edge computing, we present a framework that automatically transforms client-cloud apps to their client-edge-cloud versions. Our framework, EdgStr, automatically replicates cloud-based services at the edge. EdgStr synchronizes the replicated service state by relying on a third-party Conflict-Free Replicated Data Type (CRDT). It generates code that connects service state changes to CRDT update operations, thus ensuring that the state changes at each replica eventually converge to the same replicated state. As an evaluation, we applied EdgStr to transform representative distributed mobile apps for deployment in dissimilar network and device setups. EdgStr correctly replicates cloud services (targeting the important domain of Node.js), deploying the resulting replicas on an ad-hoc edge cluster, hosted by Raspberry PI devices. As long as eventual consistency is congruent with the functionality of a cloud service, EdgStr can automatically replicate this service and deploy the replicas at the edge, thus offering the performance benefits of edge-based execution, without the high costs of manual program transformation.

In a mobile web app, a browser-based client communicates with a cloud-based server across the network. An app is statically divided into client and server functionalities, so the resulting division remains fixed at runtime. However, if such static division mismatches the current network conditions and the device’s processing capacities, app responsiveness and energy efficiency can deteriorate rapidly. To address this problem, we present Communicating Web Vessels (CWV), an adaptive redistribution and replication framework that improves the responsiveness of full-stack JavaScript mobile apps. Unlike standard computation offloading, in which client functionalities move to run on the server, CWV’s redistribution is bidirectional. Without any preprocessing, CWV enables apps to move any functionality from the server to the client and vice versa at runtime, thus adapting to the ever-changing execution environment of the web. Having moved to the client, former server functionalities become regular local functions. To further improve performance, CWV can replicate server-side functionalities on the client and keep the replicas consistent. By monitoring the network, CWV determines if a redistribution or a replication would improve app performance, and then analyzes, transforms, sandboxes, moves, or replicates functions and program state at runtime. An evaluation with third-party mobile web apps shows that CWV optimizes their performance for dissimilar network conditions and client devices. As compared to their original versions, CWV-powered web apps improve their performance (i.e., latency, energy consumption), particularly when executed over limited networks.1

Distributed applications enhance their execution by using remote resources. However, distributed execution incurs communication, synchronization, fault-handling, and security overheads. If these overheads are not offset by the yet larger execution enhancement, distribution becomes counterproductive. For maximum benefits, the distribution's granularity cannot be too fine or too crude; it must be just right. In this paper, we present a novel approach to re-architecting distributed applications, whose distribution granularity has turned ill-conceived. To adjust the distribution of such applications, our approach automatically reshapes their remote invocations to reduce aggregate latency and resource consumption. To that end, our approach insources a remote functionality for local execution, splits it into separate functions to profile their performance, and determines the optimal redistribution based on a cost function. Redistribution strategies combine separate functions into single remotely invocable units. To automate all the required program transformations, our approach introduces a series of domain-specific automatic refactorings. We have concretely realized our approach as an analysis and automatic program transformation infrastructure for the important domain of full-stack JavaScript applications, and evaluated its value, utility, and performance on a series of real-world cross-platform mobile apps. Our evaluation results indicate that our approach can become a useful tool for software developers charged with the challenges of re-architecting distributed applications.

Modern web applications are distributed across a browser-based client and a cloud-based server. Distribution provides access to remote resources, accessed over the web and shared by clients. Much of the complexity of inspecting and evolving web applications lies in their distributed nature. Also, the majority of mature program analysis and transformation tools works only with centralized software. Inspired by business process re-engineering, in which remote operations can be insourced back in house to restructure and outsource anew, we bring an analogous approach to the re-engineering of web applications. Our target domain are full-stack JavaScript applications that implement both the client and server code in this language. Our approach is enabled by Client Insourcing, a novel automatic refactoring that creates a semantically equivalent centralized version of a distributed application. This centralized version is then inspected, modified, and redistributed to meet new requirements. After describing the design and implementation of Client Insourcing, we demonstrate its utility and value in addressing changes in security, reliability, and performance requirements. By reducing the complexity of the non-trivial program inspection and evolution tasks performed to meet these requirements, our approach can become a helpful aid in the re-engineering of web applications in this domain.

Real-time systems must meet strict timeliness requirements. These systems also often need to protect their critical program information (CPI) from adversarial interference and intellectual property theft. Trusted execution environments (TEE) execute CPI tasks on a special-purpose processor, thus providing hardware protection. However, adapting a system written to execute in environments without TEE requires partitioning the code into the regular and trusted parts. This process involves complex manual program transformations that are not only laborious and intellectually tiresome, but also hard to validate and verify for the adherence to real-time constraints. To address these problems, this paper presents novel program analyses and transformation techniques, accessible to the developer via a declarative meta-programming model. The developer declaratively specifies the CPI portion of the system. A custom static analysis checks CPI specifications for validity, while probe-based profiling helps identify whether the transformed system would continue to meet the original real-time constraints, with a feedback loop suggesting how to modify the code, so its CPI can be isolated. Finally, an automated refactoring isolates the CPI portion for TEE-based execution, communicated with through generated calls to the TEE API. We have evaluated our approach by successfully enabling the trusted execution of the CPI portions of several microbenchmarks and a drone autopilot. Our approach shows the promise of declarative meta-programming in reducing the programmer effort required to adapt systems for trusted execution under real-time constraints.

In this paper, we introduce a simulation approach for emulating a real-world human recognition system called a Perception Sensor Network (PSN). The proposed PSN system has fusion components for automatic localization and facial recognition that uses multiple Kinect sensors and pan-tilt-zoom (PTZ) cameras. We verified that the generic vision schemes utilized in human detection and facial recognition algorithms were interoperable in a scenario that consisted of virtual avatar humans. In experiments, we tested a perception scenario in which multiple humans in a 3D simulation space are automatically recognized in both location and identification with real-world system parameters.

This work proposes a novel packet urgency metric-based cross-layer design of packet scheduling and routing algorithms to effectively deliver video streaming data over mobile ad hoc networks based on IEEE 802.11 multi-rate service. First, the packet urgency, node urgency, and route urgency are defined on the basis of the residual time to the destination. Furthermore, the one-hop transmission delay of each packet is estimated using a Kalman filter. Next, the packet scheduling algorithm is proposed to minimize the node urgency without unnecessary packet drops based on both these urgency metrics and the estimated transmission delay. The proposed routing algorithm constructs a route to minimize the derivative of route urgency in order to maximize the number of packets delivered within the required end-to-end delay and distribute the entire traffic load. Finally, simulation results are provided to demonstrate the performance of the proposed cross-layer system.

In this work, we introduce a 3D simulation framework for multi-human detection using multi-sensor. We build a 3D indoor space by modeling the real dimensions of a classroom using the 3D creation tool Blender. We also create human animations like sitting down and sleeping using its game engine. The multi-sensor frame consists of two RGB and two depth cameras simulated with the aid of the simulator MORSE. In addition, we examine the feasibility of simulation by testing the baseline vision method of face and human detection on a textured human animation.

This work presents a tightly-coupled packet scheduling and routing algorithm to effectively transmit delay- sensitive media over mobile ad hoc network. First, packet urgency, node urgency, and route urgency are defined based on the end-to-end delay requirement of each packet and the number of hops over a route. Packet scheduling algorithm and packet drop policy are designed to maximize the number of packets delivered in the tolerable delay bound and minimize their node urgency at each node simultaneously. Finally, the routing algorithm is implemented to search for a route with the minimum route urgency.