Web applications (web apps) have become a key arena for large language models (LLMs) to demonstrate their code generation capabilities and commercial potential.However, building a benchmark for LLM-generated web apps remains challenging due to the need for realworld user requirements, generalized evaluation metrics without relying on ground-truth implementations or test cases, and interpretable evaluation results.To address these challenges, we introduce WebCoderBench, the first realworld, generalized, and interpretable benchmark for web app generation.WebCoderBench comprises 1,572 real user requirements, covering diverse modalities and expression styles that reflect realistic user intentions.Web-CoderBench provides 24 fine-grained evaluation metrics across 9 perspectives, combining the rule-based and LLM-as-a-judge paradigms for fully automated, objective, and general evaluation.Moreover, WebCoderBench adopts human-preference-aligned weights over metrics to yield interpretable overall scores.Experiments across 12 representative LLMs and 2 LLM-based agents show that there exists no dominant model across all evaluation metrics, offering an opportunity for LLM developers to optimize their models in a targeted manner for a more powerful version.

Vision Language Models (VLMs) are foundational for low-latency, privacy-preserving on-device AI in real-time applications like UI agents and VQA. The VLM prefilling phase, which processes the entire visual-textual input, faces the critical challenge of a long Time-to-First-Token (TTFT). One promising approach to reduce TTFT is to exploit the temporal locality by reusing block-level computations across consecutive frames. Unfortunately, current Transformer-based VLMs break the spatial invariance of CNNs and invalidate the strict-prefix KV-cache mechanism of decoder-only LLMs; in practice, even a single-pixel mismatch can prevent reuse.

Automated web GUI testing approaches aim to maximize the code coverage of a web app within a specific time budget. However, due to the highly dynamic characteristics of web apps, testing approaches often get stuck in loops or repeatedly explore the same app areas. To address this issue, existing approaches conduct state abstraction, grouping similar pages into the same state in an effort to approximate the ideal state (i.e., a state that encompasses all-and-only those pages exhibiting the same behavior from a testing perspective) to reduce repetitive explorations. Typically, these approaches rely on the Document Object Model (DOM) or visual similarity, using predefined thresholds or learning-based classifiers to determine which pages should belong to the same state. However, pages within the same ideal state still exhibit discrepancies, caused by factors such as dynamically loaded data and dynamically expanded UI elements. The varying page complexities and design styles among apps bring even more challenges. These phenomena present substantial obstacles to existing approaches in determining desirable classification thresholds or training desirable classifiers, preventing them from conducting satisfactory state abstraction to guide the testing process. To address the preceding challenges, in this article, we propose Judge, a novel approach based on structure merging and contrastive learning for state abstraction. Judge includes a “merge-and-classify” strategy. In the “merge” phase, Judge iterates through the DOM tree of each given page and merges web element siblings that share the same subtree structure into a single one to abstract and simplify the page, while discarding text contents and HTML attributes of web elements in the process. In this way, Judge mitigates the negative effects introduced by dynamically loaded data and dynamically expanded UI elements, substantially reducing discrepancies between pages in the same ideal state. In the “classify” phase, Judge uses a dedicated contrastive learning model to embed simplified page DOMs into vectors and further conducts classification with a Support Vector Machine (SVM), enabling classification in high-dimensional vector space and improving generalizability across diverse web apps. We evaluate Judge against 13 widely used baseline approaches. The results highlight that Judge outperforms these baseline approaches in classifying page pairs, with an average margin ranging from 8.95% to 28.90% in the F1 score across three manually labeled datasets. Additionally, when compared to the five most effective baseline approaches, Judge demonstrates superiority in guiding the exploration of automated web GUI testing in six widely studied apps, with code coverage improved by an average of 2.62–14.12%. The code and data of Judge are publicly accessible.

Generative tasks, such as text generation and question answering, are essential for mobile applications. Given their inherent privacy sensitivity, executing them on devices is demanded. Nowadays, the execution of these generative tasks heavily relies on the Large Language Models (LLMs). However, the scarce device memory severely hinders the scalability of these models. We presentEdgeLLM, an efficient on-device LLM inference system for models whose sizes exceed the device's memory capacity.EdgeLLMis built atop speculative decoding, which delegates most tokens to a smaller, memory-resident (draft) LLM.EdgeLLMintegrates three novel techniques: (1) Instead of generating a fixed width and depth token tree,EdgeLLMproposes compute-efficient branch navigation and verification to pace the progress of different branches according to their accepted probability to prevent the wasteful allocation of computing resources to the wrong branch and to verify them all at once efficiently. (2) It uses a self-adaptive fallback strategy that promptly initiates the verification process when the smaller LLM generates an incorrect token. (3) To not block the generation,EdgeLLMproposes speculatively generating tokens during large LLM verification with the compute-IO pipeline. Through extensive experiments,EdgeLLMexhibits impressive token generation speed which is up to 9.3× faster than existing engines.

JavaScript (JS) obfuscation is now prevalent among popular websites and introduces challenges for malware detection and code review. Given an obfuscated JS program, existing deobfuscation techniques aim to recover the original JS program. However, these techniques overlook structural obfuscation (e.g., control-flow flattening), which causes deobfuscation to have a sub-optimal success rate. To address these challenges, in this article, we propose the first approach of structural deobfuscation named JSimpo for JS programs with two novel techniques: slice symbolic execution and dynamic code execution. We implement our JSimpo approach and evaluate it on 2,000 JS programs from the top 100 JS projects on GitHub. The evaluation results show that JSimpo can effectively conduct structural deobfuscation, boosting the average structural similarity to 78.41% (from 39.33%) between obfuscated programs and their original programs, whereas the best of the state-of-the-art/practice deobfuscators can achieve only 62.64%. The results also show JSimpo's generalization ability over programs obfuscated by various obfuscators. Additionally, JSimpo preserves the semantics of deobfuscated programs by passing all test cases that obfuscated programs have passed.

This article conducts fairness testing of automated pedestrian detection, a crucial but under-explored issue in autonomous driving systems. We evaluate eight state-of-the-art deep learning-based pedestrian detectors across demographic groups on large-scale real-world datasets. To enable thorough fairness testing, we provide extensive annotations for the datasets, resulting in 8,311 images with 16,070 gender labels, 20,115 age labels, and 3,513 skin tone labels. Our findings reveal significant fairness issues, particularly related to age. The proportion of undetected children is 20.14% higher compared to adults. Furthermore, we explore how various driving scenarios affect the fairness of pedestrian detectors. We find that pedestrian detectors demonstrate significant gender biases during night time, potentially exacerbating the prevalent societal issue of female safety concerns during nighttime out. Moreover, we observe that pedestrian detectors can demonstrate both enhanced fairness and superior performance under specific driving conditions, which challenges the fairness-performance tradeoff theory widely acknowledged in the fairness literature. We publicly release the code, data, and results to support future research on fairness in autonomous driving.

Serverless computing is a popular cloud computing paradigm that has found widespread adoption across various online workloads. It allows software engineers to develop cloud applications as a set of functions (called serverless functions ). However, accurately measuring the performance (i.e., end-to-end response latency) of serverless functions is challenging due to the highly dynamic nature of the environment in which they run. To tackle this problem, a potential solution is to apply checks of performance testing techniques to determine how many repetitions of a given serverless function across a range of inputs are needed to cater to the performance fluctuation. However, the available literature lacks performance testing approaches designed explicitly for serverless computing. In this article, we propose the first serverless computing-oriented performance testing (SCOPE) approach. SCOPE takes into account the unique performance characteristics of serverless functions, such as their short execution durations and on-demand triggering. As such, SCOPE is designed as a fine-grained analysis approach. SCOPE incorporates the accuracy check and the consistency check to obtain the accurate and reliable performance of serverless functions. The evaluation shows that SCOPE provides testing results with 97.25% accuracy, 33.83 percentage points higher than the best currently available technique. Moreover, the superiority of SCOPE over the state-of-the-art holds on all functions that we study.

Federated learning (FL) is a privacy-preserving deep learning paradigm. An important type of FL is cross-silo FL, which enables a moderate number of organizations to cooperatively train a shared model while keeping private data locally and aggregating parameters on a central parameter server. However, the central server may be vulnerable to malicious attacks or software failures. To address this problem, Swarm Learning (SL) has emerged to perform FL in a decentralized manner by introducing a blockchain to securely onboard members and dynamically elect the leader for parameter aggregation. Despite tremendous attention to SL recently, few measurement studies provide comprehensive knowledge of best practices and precautions for deploying SL in real-world scenarios. To this end, we conduct the first empirical study of SL, to fill the knowledge gap between SL research and real-world deployment. We conduct various experiments on 3 public datasets for 4 research questions, present interesting findings, quantitatively analyze the reasons behind these findings, and provide developers and researchers with practical suggestions.

Tests for feature-based UI testing have been indispensable for ensuring the quality of mobile applications (apps for short). The high manual labor costs to create such tests have led to a strong interest in automated feature-based UI testing, where an approach automatically explores the App under Test (AUT) to find correct sequences of UI events achieving the target test objective, given only a high-level test objective description. Given that the task of automated feature-based UI testing resembles conventional AI planning problems, large language models (LLMs), known for their effectiveness in AI planning, could be ideal for this task. However, our study reveals that LLMs struggle with following specific instructions for UI testing and replanning based on new information. This limitation results in reduced effectiveness of LLM-driven solutions for automated feature-based UI testing, despite the use of advanced prompting techniques. Toward addressing the preceding limitation, we propose Guardian, a runtime system framework to improve the effectiveness of automated feature-based UI testing by offloading computational tasks from LLMs with two major strategies. First, Guardian refines UI action space that the LLM can plan over, enforcing the instruction following of the LLM by construction. Second, Guardian deliberately checks whether the gradually enriched information invalidates previous planning by the LLM. Guardian removes the invalidated UI actions from the UI action space that the LLM can plan over, restores the state of the AUT to the state before the execution of the invalidated UI actions, and prompts the LLM to re-plan with the new UI action space. We instantiate Guardian with ChatGPT and construct a benchmark named FestiVal with 58 tasks from 23 highly popular apps. Evaluation results on FestiVal show that Guardian achieves 48.3

Small satellites (SmallSats) are now widely used in various fields, such as real-time communication and earth observation. These increasingly complex space applications face limited support from conventional radiation-hardened processors onboard. Hence, many SmallSats are designed to utilize high performance commercial off-the-shelf (COTS) computing devices to address this problem but it remains unclear how the unique energy and thermal characteristics of SmallSats impact computing efficiency onboard. This work conducts a systematic and quantitative measurement study of COTS devices’ computing efficiency on two real orbiting SmallSats. The key findings are: 1) inadequate energy management may lead to electricity wastage in sunlit zones and shortages in eclipse zones, impacting onboard computing availability and 2) the weak heat dissipation onboard may compromise COTS computing efficiency by incurring thermal throttling. To address such challenges, we design ProScale, a lightweight application-aware power management and thermal control system to improve computing efficiency under both electrical and thermal energy constraints. Evaluation shows that ProScale can improve the average task completion latency by $2.1 \times$ for computation-intensive applications compared with baselines.

On-device training Neural Networks (NNs) has been a crucial catalyst towards privacy-preserving and personalized mobile intelligence. Recently, a novel training paradigm, namely Parameter-Efficient Training (PET), is attracting attention in both the machine learning and system community. In our preliminary measurements, we find PET well-suited for on-device scenarios; yet, its parameter efficiency does not translate coequal to time efficiency on resource-constrained devices, as the training time is dominated by the frozen layers.

IoT blockchain suffers heavy performance issues because of the massive transactions generated by various IoT nodes. By dividing nodes into different shards, sharding can produce blocks in parallel and hence improve the throughput of the blockchain system. Unlike the traditional blockchain system, IoT blockchain mainly consists of smart devices and the transactions are usually generated from the real world, such as the sensor data, photos taken by cameras, and so on. In IoT blockchain, closer nodes usually share a lower network latency and the transactions they generate are more related. Therefore, location-based sharding is an effective approach to improve the performance of IoT blockchain. Traditionally, IoT nodes are di-vided into different shards based on geographical locations or the connected edge server. However, the key challenge of sharding in IoT blockchain is how to guarantee the equality of shards division as to the unpredictable distribution and the dynamic behavior of IoT nodes. On one hand, shards can not be pre-divided because we can not predict the number or the distribution of the IoT nodes. On the other hand, nodes continuously joining or quitting shards will also break the equality of the shards division. In this paper, we propose Fission, a sharding mechanism designed for IoT blockchain. Fission divide shards based on the Voronoi diagram without any preknowledge about the nodes distribution, and support dynamic, autonomous sharding adjustment based on distributed Delaunay Triangulation. In addition, Fission uses a new diffusion-based consensus algorithm to achieve the linear scalability of throughput. The experimental results show that Fission can construct and adjust shards at a very low cost and can execute in a decentralized manner. The throughput can reach 1900tps in 500 nodes with only 5M bps bandwidth, and can scale linearly as the nodes increase.

Privacy leakage is a forever critical issue for data sharing and cooperation. Therefore, many Privacy-Preserving-Computation-aimed services (PPCS) are published to provide a secure environment in which data can be processed in its encrypted or opaque state by specific programs (i.e. PPCS program). However, PPCS programs still face the risk of privacy leakage due to the intentionally or careless designed privacy leakage vulnerabilities (PLV) that may leak sensitive data in the returned result. Unfortunately, traditional PLV-detection approaches like quantitative estimation and taint analysis become inefficient for these PLVs due to the extremely large input domain and the complex data-processing logic of PPCS programs. In this paper, we propose a fuzzing-based approach named FuzzLeaks to detect PLVs. It uses coverage-oriented fuzz testing to generate test cases for checking PPCS programs and thus to carry out leakage estimation to detect PLVs. It effectively quantifies privacy leakage under the extremely large input domain via path-sensitive byte-level entropy analysis, and handles the complex data-processing logic via input mutation based on dynamic information flow analysis. We implement FuzzLeaks and validate it on the PLDA data set and LAVA-M data set. The experimental results show that FuzzLeaks outperforms traditional approaches in accuracy by 35.72% on the PLDA dataset, and the dynamic-analysis-based mutation guidance adopted by FuzzLeaks can even resulted in 50 more non-PLV bugs found on the LAVA-M data set.

The development of Web technology and the beginning of the Big Data era have led to the development of technologies for extracting data from websites, such as information retrieval (IR) and robotic process automation (RPA) tools. As websites are constantly evolving, to prevent these tools from functioning improperly due to website evolution, it is important to monitor the changes in websites and report them to the developers and testers. Existing monitoring tools mainly use DOM-tree based techniques to detect changes in the new web pages. However, these monitoring tools incorrectly report content-based changes (i.e., web content refreshed every time a web page is retrieved) as the changes that will adversely affect the performance of the IR and RPA tools. This results in false warnings since the IR and RPA tools typically consider these changes as expected and retrieve dynamic data from them. Moreover, these monitoring tools cannot identify GUI widget evolution (e.g., moving a button), and thus cannot help the IR and RPA tools adapt to the evolved widgets (e.g., automatic repair of locators for the evolved widgets). To address the limitations of the existing monitoring tools, we propose an approach, WebEvo, that leverages historic pages to identify the DOM elements whose changes are content-based changes, which can be safely ignored when reporting changes in the new web pages. Furthermore, to identify refactoring changes that preserve semantics and appearances of GUI widgets, WebEvo adapts computer vision (CV) techniques to identify the mappings of the GUI widgets from the old web page to the new web page on an element-by-element basis. Empirical evaluations on 13 real-world websites from 9 popular categories demonstrate the superiority of WebEvo over the existing DOM-tree based detection or whole-page visual comparison in terms of both effectiveness and efficiency.

The past decades witnessed the fast and wide deployment of Internet. The Internet has bred the ubiquitous computing environment that is spanning the cloud, edge, mobile devices, and IoT. Software running over such a ubiquitous computing environment environment is eating the world. A recently emerging trend of Internet-based software systems is “ resource adaptive ,” i.e., software systems should be robust and intelligent enough to the changes of heterogeneous resources, both physical and logical, provided by their running environment. To keep pace of such a trend, we argue that some considerations should be taken into account for the future operating system design and implementation. From the structural perspective, rather than the “monolithic OS” that manages the aggregated resources on the single machine, the OS should be dynamically composed over the distributed resources and flexibly adapt to the resource and environment changes. Meanwhile, the OS should leverage advanced machine/deep learning techniques to derive configurations and policies and automatically learn to tune itself and schedule resources. This article envisions our recent thinking of the new OS abstraction, namely, ServiceOS , for future resource-adaptive intelligent software systems. The idea of ServiceOS is inspired by the delivery model of “ Software-as-a-Service ” that is supported by the Service-Oriented Architecture (SOA). The key principle of ServiceOS is based on resource disaggregation, resource provisioning as a service, and learning-based resource scheduling and allocation. The major goal of this article is not providing an immediately deployable OS. Instead, we aim to summarize the challenges and potentially promising opportunities and try to provide some practical implications for researchers and practitioners.

Exploring and mining the explosive burst of "big data" has already generated a lot of innovative applications, especially the recent advances of AI applications, and thus produced big values to the human society and civilization. However, due to the centralized patterns of data governance activities, including creation, sharing, exchange, management, analytics, tracing, and accounting, the potential values of big data distributed on the Internet are far away from being adequately explored. The recent announcement of data protection policies/laws such as GDPR makes the problem even more challenging. We are now at a moment of truth where the data governance infrastructure should be reconsidered and redesigned. In this paper, we propose a software-defined infrastructure design in a decentralized fashion: data owners are able to implement and deploy their own rules to the application systems where the data are produced for further governance activities. Such a fashion is quite similar to the popular software-defined networking where users are allowed to deploy rules of switches and customize the use. Our principled infrastructure design can radically reform the current data governance activities into a decentralized topology. On the one hand, data can be separated from the application that generates the data, and data owners can have the full rights to decide where their data should be stored and how the data can be shared. On the other hand, data users can search, discover, integrate, and analyze the data from various data sources according to their application requirements and scenarios. As a result, we argue that our infrastructure can establish a new generation of responsive decentralized data governance that can promote the innovation of linking data to better adapt the open environment and diverse user requirements. With this perspective, we briefly discuss some key insights and enumerate several related new technologies and open challenges.

Summary In the presence of scale, dynamism, uncertainty, and elasticity, cloud engineers face several challenges when allocating resources for cloud‐based software services. They should allocate appropriate resources in order to guarantee good quality of services as well as low cost of resources. Self‐adaptive ability is needed in this process because engineers' intervention is difficult. Traditional self‐adaptive resource allocation methods are policy‐driven. Thus, cloud engineers usually have to develop separate sets of rules for each systems in order to allocate resources effectively, which leads to high administrative cost and implementation complexity. Machine learning has made great achievements in many fields, and it can be also applied to resource allocation. In this paper, we present a self‐learning and self‐adaptive approach to resource allocation for cloud‐based software services. For a given cloud‐based software service, its QoS model is firstly trained on history data, which is capable to predict the QoS value as output by using the information on workload and allocated resources as inputs. Then, on‐line decision‐making on resource allocation can be carried out automatically based on genetic algorithm, which is aimed to search reasonable resource allocation plan by using the QoS model. We evaluate our approach on RUBiS benchmark, demonstrating the accuracy of the QoS model over 90% and the improvement of resource utilization by 10%‐30%.

Mobile Web applications (a.k.a., Web apps) stand for an important trend for next-generation Internet-based software. Currently popular mobile Web apps need to be adapted to various and ever-changing contexts and personalized user requirements. Based on our over-decade research experiences and practice on the Internetware paradigm, this position article describes an Internetware-oriented approach to designing, developing, and deploying situational mobile Web apps, by synthesizing the resources and services of mobile and cloud. Guided by a novelService-Model-View-Controller(SMVC) software model, a mobile Web app is organized into a well-defined structure that facilitates adaptation including online/offline data access, computation offloading, user interface optimization, hybrid composition, etc. We provide efficient runtime support spanning mobile and cloud to make mobile Web apps more flexibly adaptive. The proof-of-concept evaluation demonstrates that our approach can benefit end-users with optimized user experience of mobile Web apps.

In cloud computing environments, data centers can provide high-performance computing resources and distributed storage space. Scientific workflows often need to be implemented across multiple data centers, where copious amounts of application data are stored. Moving data across geographically distributed data centers leads to intolerable delays and hinders the efficient execution of scientific workflows, which are large-scale data-intensive. Reasonable data placement can reduce data scheduling between the data centers effectively. In this paper, an adaptive discrete particle swarm optimization (PSO) algorithm based on genetic algorithm has been proposed to decrease the number of data transmissions across data centers. The algorithm overcame the premature convergence defect of PSO by introducing the mutation and crossover of genetic algorithm. Moreover, it effectively improved the diversity in the process of population evolution. Compared with the previous work, the simulation results showed that the proposed strategy greatly reduced the volume of data transfer while reducing the number of data movement across data centers.

Collaborative work supported by mobile applications has become more and more popular. Mobile collaboration in some cases needs to be conducted in an interactive way to allow the sharing of the requester screen with the collaborator. Existing interactive screen sharing techniques, however, may cause heavy network traffic and high latency and lack fine-grained control of the scope of collaboration. In this paper, we propose CollaDroid, a lightweight and UI Description based technique for interactive collaboration of Android applications. CollaDroid can automatically transform an Android application to a collaboration augmented application with which a requester can interactively collaborate with a remote collaborator by synchronizing UI (User Interface) content and events. The results of our experimental study show that CollaDroid is applicable for a large part of applications in the Android Market and can provide an efficient collaboration mechanism with low network traffic and latency. And the results of our user study show that the collaboration mechanism implemented by CollaDroid is well accepted by users.

The prevalence of mobile platforms, especially the large market share of Android, has promoted the popularity of mobile applications (a.k.a. apps). In developing the apps, logging acts as a crucial tool to help developers debug their app before publishing. In this paper, we present an empirical study on how logging is used in current popular Android apps and reveal the security risks of deactivating the log call instead of removing the call and its associated instructions. To this end, we propose a static analysis scheme to remove the logging call as well as those associated instructions that construct the parameters for the call. We then implement the scheme as a tool called LogPruner and evaluate it with a set of 10 top apps collected from Google Play and Wandoujia. The results show that LogPruner can outperform the naive logging removal approach by 11.8% to 512.5% on pruned instructions in the collected apps.

The internet of things (IoT) attracts great interest in many application domains concerned with monitoring and control of physical phenomena. IoT applications try to provide more and more functionality and then they inevitably become so complex as to make the limits of devices worse, which may lead to poor performance of applications. Computation offloading is a promising way to improve the performance of an IoT application by executing some parts of the application on remote devices or servers. However, supporting such capability is not easy for application developers due to (1) adaptability: IoT applications often face changes of runtime environments so that the adaptation on offloading is needed. (2) effectiveness: when the device context changes, it needs to dynamically decide the deployment plan of computation tasks, and the reduced execution time must be greater than the network delay and extra overheads caused by offloading. This paper proposes a framework which supports IoT applications with adaptive computation offloading capability. First, a design pattern is proposed to enable an application to be computation offloaded on-demand. Second, an estimation model is presented to automatically decide the deployment plan for offloading. Third, a framework is implemented to support the design pattern and the estimation model. A thorough evaluation on the real-world application is proposed, and the results show that our approach can help reduce execution time by over 45% in most scenarios.

Cloud computing has emerged as a new paradigm for services delivering over the Internet. In this growing market, PaaS (Platform-as-a-Service) cloud has been an important model allowing a simple and flexible deployment of applications, without the need for dedicated networks, servers, storage and other services. Many PaaS services have been provided in the past few years and it is required to use hybrid PaaS services in order to satisfy management requirements such as legacy system integration and dynamic resource scaling. However, there are various management interfaces and different management mechanisms among PaaS clouds, which cause great difficulty and high complexity to application deployment in a hybrid cloud. In this paper, we present a runtime model based approach to using hybrid PaaS services. First, the manageability of PaaS services is abstracted as runtime models that are automatically connected with the corresponding systems. Second, we provide a unified model of PaaS services, according to the domain knowledge of current PaaS clouds. Third, the synchronization between the unified model and runtime models is ensured through model transformation. Thus, administrators are able to use hybrid PaaS services in a unified manner and management logic can be also carried out by executing programs on the unified model, which decreases the difficulty and complexity of hybrid cloud management.

Mobile devices with 3G/4G networking often waste energy in the so-called "tail time" during which the radio is kept on even though no communication is occurring. Prior work has proposed policies to reduce this energy waste by batching network requests. However, this work is challenging to apply in practice due to a lack of mechanisms. In response, we have developed DelayDroid, a framework that allows a developer to add the needed policy to existing, unmodified Android applications (apps) with no human effort. This allows such prior work (as well as our own policies) to be readily deployed and evaluated. The DelayDroid compile-time uses static analysis and bytecode refactoring to identify method calls that send network requests and modify such calls to detour them to the DelayDroid run-time. The run-time then applies a policy to batch them, avoiding the tail time energy waste. DelayDroid also includes a cross-app communication mechanism that supports policies that optimize across multiple apps running together, and we propose a policy that does so. We evaluated the correctness and universality of the DelayDroid mechanisms on 14 popular Android apps chosen from the Google App Store. To evaluate our proposed policy, we studied three DelayDroid-enabled apps (weather forecasting, email client, and news client) running together, finding that the DelayDroid mechanisms combined with our policy can reduce 3G/4G tail time energy waste by 36%.

Fault tolerance (FT) is one of the most important ways to achieve high availability (HA). However, as for cloud, with diverse user requirements, heterogeneous cloud providers, complex FT implementation as well as error-prone configuration, it is a real challenge. To cope with it, we proposed a model defined FT approach which automatically deploys FT mechanisms following a high-level model. With the help of FT model, the existing FT mechanisms will be optimized by reusability. We implemented a prototype of our approach and evaluated it on a popular IaaS cloud - CloudStack.

With the rapid development of Cloud computing technologies, a large number of Cloud management systems have emerged in recent years, such as Amazon EC2, Eucalyptus, CloudStack and OpenStack. To the best of our knowledge, all of these systems treat virtual machines (VMs) independent with each other and ignore the relationships between them. However, the relationship information between VMs can greatly impact the resource utilization, application performance and so on. Therefore, in this paper, we present SmartRelationship – a relationship detection framework for Cloud management. The framework detects the relationship between VMs in Cloud, which can be used to optimize Cloud management services such as VM dynamic placement, fault detection and security inspection.

Managing computation resources in a cost-effective way has become the core competence for a Cloud provider to win over the market because of the "pay-as-you-go" business model. Therefore, VM placement has become more and more important in the research and practices of VM management by determining at what condition and on which physical server a VM should be placed so that the SLA can be guaranteed and servers' utilization can be improved. Much existing work simply formulates the above issue to be a bin-packing problem, which does not take the VM relationships into account. However, the relationship information can greatly impact the SLA of the Cloud system and the resource utilization. Therefore, in this paper, we propose a relationship-based VM placement framework, SmartCRS, to optimize the VM placement procedure. SmartCRS reveals the relationships between VMs automatically. Then by using such information and based on a constraint library, it gives a proper VM placement plan. Finally, the plan is carried out by SmartCRS automatically or by Cloud administrators manually to improve the server utilization and guarantee the required SLA. Two case studies are conducted to demonstrate the effectiveness and efficiency of the proposed framework at the end of this paper.

Although there are many management systems, Cloud management still faces with great challenges, due to the diversity of Cloud resources and ever-changing management requirements. Integration and adaptation become important for constructing a cloud management system, because a redevelopment solution based on existing systems is usually more practicable than developing the management system from scratch. However, the workload of redevelopment is also very high. As the runtime model is causally connected with the corresponding running system automatically, constructing an integrated Cloud management system based on runtime models can benefit from the model-specific natures to reduce the development workload. Therefore, in this paper, we present a runtime model based approach to constructing cloud management system. First, we construct the runtime model of each Cloud resource based on its own management interfaces. Second, we construct a composite model reflecting integration management requirements through merging the distributed runtime models. Third, we make Cloud management meet the adaptation requirements through model transformation from the composite model to the customized models specific to different administrators. Such architecture-level integrated management brings many advantages related to the interoperability, reusability and simplicity. The experiment on a real-world cloud demonstrates the feasibility, effectiveness and benefits of the new approach to integrated management of Cloud resources.

Computation offloading is a promising way to improve the performance as well as reducing the battery power consumption of a smartphone application by executing some parts of the application on a remote server. Supporting such capability is not easy for smartphone application developers due to (1) correctness: some code, e.g., that for GPS, gravity, and other sensors, can run only on the smartphone so that developers have to identify which parts of the application cannot be offloaded; (2) effectiveness: the reduced execution time must be greater than the network delay caused by computation offloading so that developers need to calculate which parts are worth offloading; (3) adaptability: smartphone applications often face changes of user requirements and runtime environments so that developers need to implement the adaptation on offloading. More importantly, considering the large number of today's smartphone applications, solutions applicable for legacy applications will be much more valuable. In this paper, we present a tool, named DPartner, that automatically refactors Android applications to be the ones with computation offloading capability. For a given Android application, DPartner first analyzes its bytecode for discovering the parts worth offloading, then rewrites the bytecode to implement a special program structure supporting on-demand offloading, and finally generates two artifacts to be deployed onto an Android phone and the server, respectively. We evaluated DPartner on three real-world Android applications, demonstrating the reduction of execution time by 46%-97% and battery power consumption by 27%-83%.

In a cloud platform belonging to the PaaS (Platform as a Service) category, autonomic middleware have become the fundamental part of a cloud node. An autonomic middleware can perform adaptive computations for self-management of the system. However, these adaptive computations consume resources such as CPU and memory, and can interfere with each other and also with normal business functions of the system due to resource competition, especially when the system is under heavy load. As a result, the adaptive computations should be tuned from the perspective of resource management. In this position paper, we propose an approach to tuning the autonomic levels and thus controlling the resource costs of the adaptive computations in an autonomic middleware of PaaS cloud, so as to guarantee the system's performance when resources are competed.

Infrastructure resources on-demand requires resource provision (e.g., CPU and memory) to be both sufficient and necessary, which is the most important issue and a challenge in Cloud Computing. Platform as a service (PaaS) encapsulates a layer of software that includes middleware, and even development environment, and provides them as a service for building and deploying cloud applications. In PaaS, the issue of on-demand infrastructure resource management becomes more challenging due to the thousands of cloud applications that share and compete for resources simultaneously. The fundamental solution is to integrate and coordinate the resource consumption and allocation management of a cloud application. The difficulties of such a solution in PaaS are essentially how to maximize the resource utilization of an application, and how to allocate resources to guarantee adequate resource provision for the system. In this paper, we propose an approach to managing infrastructure resources in PaaS by leveraging two adaptive control loops: the resource consumption optimization loop and the resource allocation loop. The optimization loop improves the resource utilization of a cloud application via management functions provided by the corresponding middleware layers of PaaS. The allocation loop provides or reclaims appropriate amounts of resources to/from the application system while guaranteeing its performance. The two loops are integrated to run consecutively and repeatedly to provide infrastructure resources on-demand by first trying to improve resource utilization, and then allocating more resources when necessary. We implement a framework, SmartRod, to investigate our approach. The experiment on SmartRod proves its effectiveness on infrastructure resource management.

Interactive tutorials, like Eclipse's cheat sheets, are good for novice programmers to learn how to perform tasks (e.g., checking out a CVS project) in an integrated development environment (IDE). Creating these tutorials often requires programming effort that is time-consuming and difficult. In this paper, we propose an approach using editable replay of user actions to help authors create interactive tutorials with little programming effort. User actions of performing a task can be recorded, edited, and presented as a tutorial. The tutorial can be replayed interactively for mentoring. We present our SmartTutor implementation in the Eclipse IDE and conduct a preliminary evaluation on it, which demonstrates efficiency gains for the tutorial authors.

Programmers often have to do many repetitive tasks when using an IDE (integrated development environment). These tasks require them to navigate through many views and dialogs in the same steps and input same data, which are time consuming and boring. In this paper, we present an approach to automatically perform the repetitive tasks by catching user actions on the IDE and replaying them when necessary. The sequence and contents of the caught user actions can be edited for generating user actions of similar tasks. The user actions are manifested as a set of high-level information so that they are easy to be edited and robust to UI changes. We present SmartReplayer, an implementation of our approach in the Eclipse IDE and use examples to show that it can greatly improve efficiency of Eclipse Programmers.