WebAssembly has been widely used in numerous fields due to its near-native execution performance, compact size, and cross-platform compatibility. However, as WebAssembly applications become increasingly complex, the size of WebAssembly files and their initialization time have also increased. Existing work addresses this issue by splitting a WebAssembly module into multiple modules and loading them on demand. Nevertheless, the total size of the split modules suffers significant bloat, which consume more server and network resources. One of the reasons is redundant types, which, in particular, contribute significantly to this bloat after WebAssembly garbage collection feature was introduced, and such redundancy cannot be reduced under the current WebAssembly specification.In this work, we have developed a tool to optimize the size of split WebAssembly modules by replacing duplicate types in secondary modules with references to types in the primary module. The reduced secondary modules are recovered during loading for module instantiation. Our experiments show that our tool can effectively reduce the size of secondary modules, achieving an average reduction of over 20% when splitting into a large number of modules. In network environments with low throughput, it can reduce loading time by 16% to 18%.

The increasing demand for high-performance Lithium-Ion Batteries (LIBs) in Electric Vehicles (EVs) underscores the need for high-quality manufacturing. A key challenge is accurately identifying electrodes and measuring anode overhang during the winding process, which directly affects battery performance and safety. Recently, Segment Anything Model (SAM) has been explored to automate data annotation for training small yet specialized segmentation models like Mask R-CNN to infer on the edge. However, SAM struggles to capture sub-pixel boundaries of thin and elongated electrodes due to fixed patch size, lack of high-frequency spatial features, and difficulty of deep fine-tuning. This leads to fragmented masks and irregular boundaries, degrading the annotation quality. On the other hand, existing mask refinement methods, designed primarily for natural images, are not directly applicable for the dense electrodes and low signal-to-noise conditions in industrial X-ray images. To bridge the research gap, a novel local-global two-stage refinement method is proposed in this paper with denoising diffusion steps. The local stage repairs breaks and refines boundary precision at electrode level, while the global stage ensures overall structural consistency across the entire battery cell. Artifact detection and secondary local refinement further improves the mask quality. Experiment results on real-world LIB data collected demonstrate the proposed method outperforms other refinement techniques with visible advancement over coarse masks, enabling more accurate overhang analysis. These findings suggest the potential to reduce manual annotation efforts, paving the way for more scalable and effective LIB manufacturing inspection.

Android currently holds a significant share of the mobile market.However, the repackaging of Android applications is a widespread issue.Attackers can use repackaging to crack applications, insert malicious code, and add or replace advertisements.This poses a serious threat to the Android ecosystem.As such, detecting repackaged applications is of great importance.Noticing that repackaged applications seldom modify the GUI of the original applications, in recent years, researchers have proposed a series of dynamic software birthmarks based on the runtime GUI of the application to detect repackaged applications.However, existing dynamic GUIbased software falls short in three areas: (1) unreliable GUI dumping channel, (2) sensitive to widget position, and (3) slow birthmark generation.To address these limits, in this paper, we propose Box-Droid.In summary, BoxDroid offers a more reliable GUI dumping channel by disregarding transparent widgets or layouts.Additionally, it significantly increases the speed of birthmark generation through a DFS exploration strategy.Finally, it generates birthmarks using the distribution of the bounding boxes of widgets in each layout encountered at runtime.We have evaluated BoxDroid on 499 repackaging pairs and it shows a precision of 0.955 and a recall of 0.926.BoxDroid also detected 1,441 undocumented repackaging pairs in a dataset sampled from the RePack repository.

Low-Rank Adaptation (LoRA) has become a widely adopted parameter-efficient fine-tuning (PEFT) technique for adapting large language models (LLMs) to downstream tasks. While prior work has explored strategies for integrating LLM training and serving, there still remains a gap in unifying fine-tuning and inference for LoRA-based models. We present **Loquetier**, a virtualized multi-LoRA framework that seamlessly integrates LoRA fine-tuning and serving within a single runtime. Loquetier introduces two key components: (1) a Virtualized Module that isolates PEFT-based modifications and supports multiple adapters on a shared base model, and (2) an optimized computation flow with a kernel design that merges fine-tuning and inference paths in forward propagation, enabling efficient batching and minimizing kernel invocation overhead. Extensive experiments across three task settings show that Loquetier consistently outperforms existing baselines in both performance and flexibility, achieving up to $3.0\times$ the throughput of the state-of-the-art co-serving system on inference-only tasks and $46.4\times$ higher SLO attainment than PEFT on unified fine-tuning and inference tasks. The implementation of Loquetier is publicly available at https://github.com/NJUDeepEngine/Loquetier.

Database-backed applications form the backbone of modern software, yet their complexity poses significant challenges for static analysis. These applications involve intricate interactions among application code, diverse database frameworks such as JDBC, Hibernate, and Spring Data JPA, and languages like Java and SQL. In this paper, we introduce DBridge, the first pointer analysis specifically designed for Java database-backed applications, capable of statically constructing comprehensive Java-to-database value flows. DBridge unifies application code analysis, database access specification modeling, SQL analysis, and database abstraction within a single pointer analysis framework, capturing interactions across a wide range of database access APIs and frameworks. Additionally, we present DB-Micro, a new micro-benchmark suite with 824 test cases crafted to systematically evaluate static analysis for database-backed applications. Experiments on DB-Micro and large, complex, real-world applications demonstrate DBridge’s effectiveness, achieving high recall and precision in building Java-to-database value flows efficiently and outperforming state-of-the-art tools in SQL statement identification. To further validate DBridge’s utility, we develop three client analyses for security and program understanding. Evaluation on these real-world applications reveals 30 Stored XSS attack vulnerabilities and 3 horizontal broken access control vulnerabilities, all previously undiscovered and real, as well as a high detection rate in impact analysis for schema changes. By open-sourcing DBridge (14K LoC) and DB-Micro (22K LoC), we seek to help advance static analysis for modern database-backed applications in the future.

Data persistence is a critical foundation for Internet of Things (IoT), it provides the capability of data collection from IoT devices and pulls out these data by queries for applications to consume. In most cases, both the relationship between devices and the metrics on devices are required, so polyglot persistence systems consisting of graph databases and time series databases are deployed for data persistence. However, as the scale of IoT device network continues to grow, polyglot persistence finds it hard to achieve the need of real-time queries demanded by query-bound applications like artificial intelligence in IoT, which is where multi-model database be proficient in.

A critical question about Large Language Models (LLMs) is whether their apparent deficiency in mathematical reasoning is inherent, or merely a result of insufficient exposure to high-quality mathematical data. To explore this, we developed an automated method for generating high-quality, supervised mathematical datasets. The method carefully mutates existing math problems, ensuring both diversity and validity of the newly generated problems. This is achieved by a neuro-symbolic data generation framework combining the intuitive informalization strengths of LLMs, and the precise symbolic reasoning of math solvers along with projected Markov chain Monte Carlo sampling in the highly-irregular symbolic space. Empirical experiments demonstrate the high quality of data generated by the proposed method, and that the LLMs, specifically LLaMA-2 and Mistral, when realigned with the generated data, surpass their state-of-the-art counterparts.

Regression errors of Deep Neural Network (DNN) models refer to the case that predictions were correct by the old-version model but wrong by the new-version model. They frequently occur when upgrading DNN models in production systems, causing disproportionate user experience degradation. In this paper, we propose a lightweight regression error reduction approach with two goals: 1) requiring no model retraining and even data, and 2) not sacrificing the accuracy. The proposed approach is built upon the key insight rooted in the unmanaged model uncertainty, which is intrinsic to DNN models, but has not been thoroughly explored especially in the context of quality assurance of DNN models. Specifically, we propose a simple yet effective ensemble strategy that estimates and aligns the two models' uncertainty. We show that a Pareto improvement that reduces the regression errors without compromising the overall accuracy can be guaranteed in theory and largely achieved in practice. Comprehensive experiments with various representative models and datasets confirm that our approaches significantly outperform the state-of-the-art alternatives.

Executing a family of Deep Neural Networks (DNNs) training jobs on the same or similar datasets in parallel is typical in current deep learning scenarios. It is time-consuming and resource-intensive because each job repetitively prepares (i.e., loads and preprocesses) the data independently, causing redundant consumption of I/O and computations. Although the page cache or a centralized cache component can alleviate the redundancies by reusing the data prep work, each job's data sampled uniformly at random presents a low sampling locality in the shared dataset that causes the heavy cache thrashing. Prior work tries to solve the problem by enforcing all training jobs iterating over the dataset in the same order and requesting each data in lockstep, leading to strong constraints: all jobs must have the same dataset and run simultaneously. In this paper, we propose a dependent sampling algorithm (DSA) and domain-specific cache policy to relax the constraints. Besides, a novel tree data structure is designed to efficiently implement DSA. Based on the proposed technologies, we implemented a prototype system, named Joader, which can share data prep work as long as the datasets share partially. We evaluate the proposed Joader in practical scenarios, showing a greater versatility and superiority over training speed improvement (up to 500% in ResNet18).

Abstract Elastic scaling in response to changes on demand is a main benefit of serverless computing. When bursty workloads arrive, a serverless platform launches many new containers and initializes function environments (known as cold starts), which incurs significant startup latency. To reduce cold starts, platforms usually pause a container after it serves a request, and reuse this container for subsequent requests. However, this reuse strategy cannot efficiently reduce cold starts because the schedulers are agnostic of container lifecycle. For example, it may ignore soon available containers or evict soon needed containers. We propose a container lifecycle‐aware scheduling strategy for serverless computing, CAS. The key idea is to control distribution of requests and determine creation or eviction of containers according to different lifecycle phases of containers. We implement a prototype of CAS on OpenWhisk. Our evaluation shows that CAS reduces 81% cold starts and therefore brings a 63% reduction at 95th percentile latency compared with native scheduling strategy in OpenWhisk when there is worker contention between workloads, and does not add significant performance overhead.

Control-based approaches to self-adaptive software-intensive systems (SASs) are hailed for their optimal performance and theoretical guarantees on the reliability of adaptation behavior. However, in practice the guarantees are often threatened by model deviations occurred at runtime. In this paper, we propose a Model-guided Deviation Detector (MoD2) for timely and accurate detection of model deviations. To ensure reliability, a SAS can switch a control-based optimal controller for a mandatory controller once an unsafe model deviation is detected. MoD2 achieves both high timeliness and high accuracy through a deliberate fusion of parameter deviation estimation, uncertainty compensation, and safe region quantification. Empirical evaluation with three exemplar systems validated the efficacy of MoD2 (93.3% shorter detection delay, 39.4% lower FN rate, and 25.2% lower FP rate), as well as the benefits of the adaptation-switching mechanism (abnormal rate dropped by 29.2%).

Android apps demand high-quality test inputs, whose generation remains an open challenge. Existing techniques fall short on exploring complex app functionalities reachable only by a long, meaningful, and effective test input. Observing that such test inputs can usually be decomposed into relatively independent short use cases, this paper presents ComboDroid, a fundamentally different Android app testing framework. ComboDroid obtains use cases for manifesting a specific app functionality (either manually provided or automatically extracted), and systematically enumerates the combinations of use cases, yielding high-quality test inputs.

Deep Neural Network models are integrated as parts of many real-world software applications. Due to the huge model size and complex computation, distributed deep learning (DDL) framework aims to provide a high-quality cluster scheduler to manage DDL training jobs from both resource allocation and job scheduling. However, existing schedulers either allocate a fixed amount of resources, or lack the control over task placement, which lead less efficient training. In this paper, we propose DeepSys, a GPU cluster scheduler tailored for DDL jobs. For single model, DeepSys builds a speed model to predict accurate training speed, and a memory model for high-quality resource utilization. For job scheduling, DeepSys considers resource allocation and task placement to provide efficient job scheduling in cluster. Experiments implemented on Kubernetes in two clusters show the advantage to the compared methods by 20% - 25% and 10% - 15% on average job completion time and makespan, respectively.

Trained DNN models are increasingly adopted as integral parts of software systems, but they often perform deficiently in the field. A particularly damaging problem is that DNN models often give false predictions with high confidence, due to the unavoidable slight divergences between operation data and training data. To minimize the loss caused by inaccurate confidence, operational calibration, i.e., calibrating the confidence function of a DNN classifier against its operation domain, becomes a necessary debugging step in the engineering of the whole system.

Software systems assisted with deep neural networks (DNNs) are gaining increasing popularities. However, one outstanding problem is to judge whether a given application scenario suits a DNN model, whose answer highly affects its concerned system's performance. Existing work indirectly addressed this problem by seeking for higher test coverage or generating adversarial inputs. One pioneering work is SynEva, which exactly addressed this problem by synthesizing mirror programs for scenario suitableness evaluation of general machine learning programs, but fell short in supporting DNN models. In this paper, we propose VISION to eValuatIng Scenario suItableness fOr DNN models, specially catered for DNN characteristics. We conducted experiments on a real-world self-driving dataset Udacity, and the results show that VISION was effective in evaluating scenario suitableness for DNN models with an accuracy of 75.6-89.0% as compared to that of SynEva, 50.0-81.8%. We also explored different meta-models in VISION, and found out that the decision tree logic learner meta-model could be the best one for balancing VISION's effectiveness and efficiency.

Widely used commercial Android applications (apps) turn to be of complex GUIs and hundreds of activities. Testing this kind of apps is challenging. Existing automated testing tools cannot complete the testing of these complex apps in a short time. However, scaling these tools for parallelism to accelerate the testing is not straightforward. In this paper, we borrow the basic concepts from parallel computing, and introduce the parallel testing platform ParaAim. ParaAim partitions an app testing job into a set of tasks at the activity granularity. Starting from a specific entrance activity, ParaAim explores the UI-states of the app and each newly discovered activity spawns a new task. ParaAim dispatches the new task to an idle device and sets it up to the entrance by replaying an event sequence. In this manner, the independent parts of the app are explored simultaneously. We focus on the efficiency of this parallel GUI exploration schema. ParaAim assigns the tasks that have more possibility to find new activities with high priority for better performance. Event sequence minimization is also studied to reduce the time cost of replay, and we design widget fuzzy match technique to handle the state inconsistency issue. We evaluated ParaAim with 20 popular commercial apps on different settings of Android device cluster. The results show that ParaAim scales well and evidently increases the average speed of exploration to nearly 2 times with two devices, and 3 times with four devices, than a single device.

This paper introduces a new, fully automated modelbased approach for effective testing of Android apps. Different from existing model-based approaches that guide testing with a static GUI model (i.e., the model does not evolve its abstraction during testing, and is thus often imprecise), our approach dynamically optimizes the model by leveraging the runtime information during testing. This capability of model evolution significantly improves model precision, and thus dramatically enhances the testing effectiveness compared to existing approaches, which our evaluation confirms.We have realized our technique in a practical tool, APE. On 15 large, widely-used apps from the Google Play Store, APE outperforms the state-of-the-art Android GUI testing tools in terms of both testing coverage and the number of detected unique crashes. To further demonstrate APE's effectiveness and usability, we conduct another evaluation of APE on 1,316 popular apps, where it found 537 unique crashes. Out of the 38 reported crashes, 13 have been fixed and 5 have been confirmed.

With the increasing adoption of Deep Neural Network (DNN) models as integral parts of software systems, efficient operational testing of DNNs is much in demand to ensure these models' actual performance in field conditions. A challenge is that the testing often needs to produce precise results with a very limited budget for labeling data collected in field.

Secondary index is used to accelerate the queries on non-rowkey columns in HBase by maintaining index items synchronously or asynchronously. Although existing asynchronous indexes have less inserting overhead than synchronous ones, they still need additional process to repair the possible inconsistency. This paper proposes an approach of embedding index repairing into data maintenance to save the extra process and meanwhile reduce the consistency-persisting cost. We implement this approach into a store engine as well as the corresponding client API, coprocessor and index-delete queue to constitute an effective secondary index building system for HBase. Experiments on YCSB benchmark show that it achieves a good balance between read and write performance, as well as better stability than other index building approaches.

Ensuring the quality of mobile applications (apps) needs to explore the GUI thoroughly. In practice, exhaustively exploring every GUI widget is unscalable on large real-world apps since it usually suffers from the problem of widgets explosion. To mitigate the problem, many existing testing tools usually detect and group homogeneous widgets heuristicly with different level of model abstraction since these widgets behave the same. However, no heuristic always works well. Heterogeneous widgets with divergent behaviors can be mistakenly grouped, which largely limits the testing effectiveness. This paper proposes a technique to effective GUI testing of Android apps with dynamic feedback-directed widgets grouping. Initially, we group the widgets according to the structure of the GUI. During testing, we observe behaviors of widgets in a group and regroup improperly-grouped widgets dynamically. Then, we apply a feedback-directed strategy to effectively accelerate the GUI exploration. The proposed technique is implemented as a practical tool for Android apps, named WGDroid. We evaluated WGDroid on 17 widely-used Android apps and compared it with the state-of-the-art GUI testing tools, i.e., AimDroid, SAPIENZ, and Monkey on both emulators and real devices. WGDroid outperformed the three tools in all testing coverages and also detected the most unique crashes. In particular, WGDroid discovered 208 more activities on 12 large benchmark apps on real devices and 11 more activities on another 5 benchmark apps on emulators, than the best of the other tools. These results show that WGDroid can significantly accelerate the GUI exploration.

Volumes of studies on resource scheduling are proposed to improve the efficiency of computing clusters. As users usually overestimate the resource requirements for their jobs, further, most schedulers ignore the dynamic variation of jobs' runtime resource usage, the utilization of real-world clusters is significantly limited. In this paper, we argue that resource oversubscription, which allocates more resources than the physical capacity, is a necessary complement to existing systems. To alleviate resource contention, we augment oversubscription with lightweight prediction and dynamic CPU throttling. We implemented our approach called Datom, which is an extension module of the Apache Mesos cluster manager. We evaluated Datom with real-world video transcoding workloads and simulations with Google cluster trace. The results show that comparing to original Mesos, Datom increased CPU utilization, memory utilization and overall task throughput by up to 22%, 23%, 20% respectively, and shortened jobs' complete time by up to 20%, at the expenses of moderate penalty on job execution.

Assertions are intensively used to facilitate correctness reasoning and error detection in daily programming. However, composing assertions for mobile robotic programs can be painfully inconvenient, because classic Hoare logic lacks the expressing power on spatial knowledge, which is crucial when robots interact with their physical environments. The problem is especially evident for Behavior-Based Robotics (BBR) where the world is not explicitly represented with program variables. In this paper, we propose to incorporate spatial reasoning capability in the assertion framework of Hoare logic. The proposed framework features a two-dimensional region calculus and additional axioms for robot movements. The calculus makes the world representation and the specification of mobile robotic program natural and intuitive, and the axioms enable the reasoning about program correctness. We illustrate the use of the framework with a typical behavior-based robotic program. In addition, we present a runtime error detection and recovery mechanism for BBR programs based on the assertion framework. Preliminary experiments with NAO robots demonstrate the effectiveness.

Dynamic software updating (DSU) is a technique to upgrade a running software system on the fly without stopping the system. During updating, the runtime state of the modified components of the system needs to be properly transformed into a new state, so that the modified components can still correctly interact with the rest of the system. However, the transformation is non-trivial to realize due to the gap between the low-level implementations of two versions of a program. This paper presents AOTES, a novel approach to automating object transformations for dynamic updating of Java programs. AOTES bridges the gap by abstracting the old state of an object to a history of method invocations, and re-invoking the new version of all methods in the history to get the desired new state. AOTES requires no instrumentation to record any data and thus has no overhead during normal execution. We propose and implement a novel technique that can synthesize an equivalent history of method invocations based on the current object state only. We evaluated AOTES on software updates taken from Apache Commons Collections, Tomcat, FTP Server and SSHD Server. Experimental results show that AOTES successfully handled 51 of 61 object transformations of 21 updated classes, while two state-of-the-art approaches only handled 11 and 6 of 61, respectively.

Nowadays statistical machine learning is widely adopted in various domains such as data mining, image recognition and automated driving. However, software quality assurance for machine learning is still in its infancy. While recent efforts have been put into improving the quality of training data and trained models, this paper focuses on code-level bugs in the implementations of machine learning algorithms. In this explorative study we simulated program bugs by mutating Weka implementations of several classification algorithms. We observed that 8%-40% of the logically non-equivalent executable mutants were statistically indistinguishable from their golden versions. Moreover, other 15%-36% of the mutants were stubborn, as they performed not significantly worse than a reference classifier on at least one natural data set. We also experimented with several approaches to killing those stubborn mutants. Preliminary results indicate that bugs in machine learning code may have negative impacts on statistical properties such as robustness and learning curves, but they could be very difficult to detect, due to the lack of effective oracles.

Apache HBase is a widely used non-relational database in the Hadoop ecosystem. However, it will be inefficient if users perform multidimensional queries. Some of existing approaches incur extra costs in write performance or consistency maintenance, others are limited to specific applications. In this paper, we propose a novel data model called CFIDM, short for Column Family Indexed Data Model. In CFIDM, we convert the queried column into multiple column families. Values in the specific column are partitioned. Each partition is manifested by a column family, turning column family into an index with no additional cost. Then we provide guides to build this data model. Finally, we evaluate the effectiveness and versatility of CFIDM on the Bixi data set and the TPC-DS benchmark. Results show that CFIDM can save 6.6% disk space for Bixi and 35% for TPC-DS, maximally speeding up the queries by 5X and 5.5X respectively.

The applications ("apps") running on Android need to be adequately tested to avoid faults. Researchers have developed a number of test input generation tools for automated app testing and tried to improve test coverage to detect as many faults as possible. However, existing testing tools achieve very low coverage for some specific apps because they highly depend on external factors to run properly such as business logic, content providers and so on. In this paper, we present Xdroid to catch when and what kind of dependencies apps require and inject them correspondingly in a lightweight way. Working with a built-in tool Xmonkey which generates GUI events directly on Android devices, Xdroid implements an effective testing engine to get a high coverage. We evaluate Xdroid with diverse Android apps and demonstrate that it outperforms Monkey for 17%, Sapienz for 22% in coverage and meanwhile reveals more bugs than manual testing. Overall, it combines the benefits of both manual testing and random testing to improve test coverage and detect bugs effectively.

Activities are the fundamental components of Android applications (apps). However, existing approaches to automated testing for Android apps cannot effectively manage the transitions between activities, e.g., too rarely or too often. Besides, some techniques need to repeatedly restart from scratch and revisit every intermediate activity to reach a specific one, which leads to unnecessarily long transitions and wasted time. To address these problems, we propose AimDroid, a practical model-based approach to automated testing for Android apps that aims to manage the exploration of activities and meantime minimize unnecessary transitions between them. Specifically, AimDroid applies an activity-insulated multi-level strategy during testing and replaying. It systematically discovers unexplored activities and then intensively exploits every discovered individual with a reinforcement learning guided random algorithm. We conduct comprehensive experiments on 50 popular closed-source commercial apps that in total have billions of daily usages in China. The results demonstrate that AimDroid outperforms both Sapienz and Monkey in activity, method and instruction coverage, respectively. In addition, AimDroid also reports more crashes than the other two.

Software frameworks are widely used in application development. But APIs of a framework may change when it evolves to accommodate new feature requests or to fix bugs. Those changes may break existing client programs of the framework, so client programs need to be migrated to the updated release when the framework evolves. Some technologies (e.g. call dependency analysis) have been proposed to find replacement APIs between the old and new framework releases. However, existing approaches based on call dependency analysis take whole method body as an analysis unit. The context in which a method is called is ignored. In this paper, we present a fine-grained approach named AUC-Miner to infer API usage change rules between two releases of the framework. To take method invocation context into consideration, we propose an approach to get more precise call relationship changes by code splitting. We also analyze indirect method invocations to re-fine call dependency analysis. After elaborating API usage change transactions, we adopt frequent item-set mining to generate API replacement rules. Text similarity and some heuristics to identify evolution of root methods are also applied in the mining progress. The evaluation of AUC-Miner on three popular frameworks shows that its precision is higher than basic call dependency analysis and another API replacement recommendation tool named AURA.

Dynamic software updating (DSU) is a technique that can update running software systems without stopping them. Most existing approaches require programmer participation to guarantee the correctness of dynamic updating. However, manually preparing dynamic updating is error-prone and time-consuming. Therefore, other approaches prefer to aggressively perform updating without programmer intervention, which may definitely lead to unanticipated runtime errors. To reduce human effort and enhance the reliability for dynamic updating, we leverage automatic runtime recovery (ARR) techniques to recover runtime errors caused by improper dynamic updating. This paper presents ADSU, a fully automatic DSU system using ARR. We evaluate ADSU with real updates from widely used open source software systems, i.e., Apache Tomcat, Apache FTP Server and jEdit. The preliminary results have shown that ADSU succeeds in automatically applying 11 of 16 real-world updates that existing counterparts cannot.

Mobile applications (apps) are mostly driven by touch gestures whose interactions are natural to human beings. However, generating gesture events for effective and efficient testing of such apps remains to be a challenge. Existing event generation techniques either feed the apps under test with random gestures or exhaustively enumerate all possible gestures. While the former strategy leads to incomplete test coverage, the latter suffers from efficiency issues. In this paper, we study the particular problem of gesture event generation for Android apps. We present a static analysis technique to obtain the gesture information: each UI component's potentially relevant gestures, so as to reduce the amount of gesture events to be delivered in the automated testing. We implemented our technique as a prototype tool GAT and evaluated it with real-world Android apps. The experimental results show that GAT is both effective and efficient in covering more code as well as detecting gesturerelated bugs.

Physical devices are valuable resources for mobile application testing, especially for compatibility testing on diverse Android devices with customized specifications of manufacturers and different operating system versions. In order to cover as many kinds of devices as possible, large quantity of physical devices are needed. Therefore, how to allocate mobile devices efficiently among testing tasks becomes a problem for engineers. We address this challenge by proposing efficient resource scheduling policy across diverse application testing frameworks. Specifically, we abstract the components of testing platforms into valid testing models. Based on the testing models, a Wait-time Fairness scheduling strategy is proposed to efficiently allocate devices among testing jobs. We have implemented our approach in a platform called Apsaras and conducted experiments on 80 physical Android devices. Results show that our approach, comparing with traditional testing methods, can carry out testing jobs more efficiently and more fairly.

Controllers restrict systems to behave only in good manners. Different from controlling monolithic systems where controllers can be automatically synthesized from specifications, controlling distributed systems often has to use distributed controllers that are manually programmed. To ensure their correctness, manually programmed controllers themselves need to be formally verified. This task can be challenging due to the complexity caused by the autonomy and asynchrony of distributed controllers. The limited scalability of existing model checkers also exacerbates the problem. In this paper we explore the modeling and verification of distributed controllers using Alloy. Besides resorting to the Small Scopes Hypothesis of the Alloy methodology, we also leverage local invariant based modular verification techniques for better scalability. A local invariant characterizes a logical relationship between a local sub-system and its neighbors and abstracts away the concrete interactions. These concrete interactions would otherwise explode the system state space during verification. The approach is first illustrated with the well-understood Two-Phase Commit protocol, and then is applied to the verification of several dynamic software update protocols, which gives an initial evidence of its effectiveness.

Dynamic reconfiguration enables components of a distributed system to be updated without restarting the whole system. One major challenge of this technology lies in how to preserve the system consistency while minimizing the disruption. Ma et al. proposed an approach to meet the challenge by managing runtime dependencies among components. However, this approach puts heavy burden on network communication as it requires components to send out every dependency changing event in each ongoing transaction, which is unnecessary in the concurrent environment. In this paper, we propose a transaction-versioning approach that identifies correct version of components for all ongoing transactions. The process can be completed within one single round of message changing among involved components. Comparing with Ma's approach, the communication overhead of our approach is linear with the system scale, which is greatly reduced especially when multiple transactions are running on the system, while the timeliness is not affected. Extensive experiments through simulation show the correctness and efficiency of our approach.

With user experience becoming richer and richer on Android smartphones, limited battery capacity has become a major concern for users. It is a good practice for Android to tell users where the battery power has gone. Android achieves this by a power profile provided by OEMs that specifies the power usage rate for each system component staying at each specific state. According to a recent study, screen is one of the most dominant power-hungry system components on Android smartphones. However, the accuracy of Android's screen power usage model is to be improved, taking not only the brightness, but also the displayed content into account. We modified Android source code to improve its screen power usage model and verified this improvement with experiments. The results show that our new screen power usage model is more accurate to a significant extent and introduces little overhead.

Contextual information is proven helpful to recommender system. And context-aware recommender system(CARS) has been applied in various applications. To improve the accuracy of context-aware recommendation and make recommender application development easier, we develop a lightweight software framework named ConRec, which introduces a dynamic context oriented approach to extend traditional reduction based recommender. This framework takes the dynamic nature of context into full consideration from different aspects to get better recommendation result. The dynamism of context exists in the process of context modeling, the computation of context weight and the handling of newly emergent context. In ConRec, context is dynamically modeled by clustering similar context values into one set automatically, rather than statically predefined by domain experts. Users' preferences to different types of context are explicitly measured through context weighting function based on real dataset. Moreover, ConRec supports incrementally adding new type of context to recommendation process, which reduces much cost of re-building the whole recommender model. Based on our improved reduction-based algorithm, ConRec is built as a highly scalable and reusable software framework for developing context-aware recommender applications. Finally, we evaluate our proposed approach on public datasets and get more accurate recommendation than traditional methods.

Hot deployment is a typical feature in mainstream application servers. But current application servers treat each module as a standalone application and may fail if a module with dependencies against other ones is partially updated with hot deploying. The reason lies in that those module dependencies are not respected in current application servers. Direct countermeasures that manage dependencies in application servers are actually inefficient or even infeasible. So in this paper, we propose an approach that automatically constructs the module dependencies with class loading mechanism which further helps to reconstruct the modular application respecting the dependencies upon hot deploying. Experiments show that our technology of hot deployment can ensure partial update of the modular applications correctly and efficiently.

Smartphone applications are becoming increasingly popular. However, these applications can suffer limited power budgets or malfunctioned sensing issues from their host devices. Computation offloading addresses this issue by delegating local computation workloads to remote servers. In this paper, we present Cose Droid, a framework that supports dynamic computation- and sensing-offloading across different Android mobile devices. This enables Android applications to virtually "borrow" computation or sensing resources from other devices. We experimentally evaluated Cose Droid with real-world Android applications. The experimental results confirmed Cose Droid's effectiveness in on-demand offloading, as well as supporting sensor variety and spontaneous sensing recovery.

Dynamic Software Update (DSU) is a technique to upgrade running programs without shutting them down. DSU can improve system availability and maintenance flexibility. However, its adoption in practice is still limited due to the risk of system misbehavior that careless DSU may bring. To reduce this risk we propose a formal framework for the specification and verification of DSU. Different from previous approaches where DSU is described from the viewpoint of program's internal state transitions, our framework focuses on program's external behavior and its effect on its environment. This more abstract view avoids over specification of DSU and allows for better DSU flexibility. Based on this framework, we also devise a mechanism that automatically synthesizes runtime monitors to improve DSU timeliness without compromising its safety.

Context-aware applications adapt their behavior based on contexts. Contexts can, however, be incorrect. A popular means to build dependable applications is to augment them with a set of constraints to govern the consistency of context values. These constraints are evaluated upon context changes to detect inconsistencies so that they can be timely handled. However, we observe that many context inconsistencies are unstable. They vanish by themselves and do not require handling. Such inconsistencies are detected due to misaligned sensor sampling or improper inconsistency detection scheduling. We call them unstable context inconsistencies (or STINs). STINs should be avoided to prevent unnecessary inconsistency handling and unstable behavioral adaptation to applications. In this article, we study STINs systematically, from examples to theoretical analysis, and present algorithms to suppress their detection. Our key insight is that only certain patterns of context changes can make a consistency constraint subject to the detection of STINs. We derive such patterns and proactively use them to suppress the detection of STINs. We implemented our idea and applied it to real-world applications. Experimental results confirmed its effectiveness in suppressing the detection of numerous STINs with negligible overhead, while preserving the detection of stable context inconsistencies that require inconsistency handling.

Applications in pervasive computing are often context-aware. However, due to uncontrollable environmental noises, contexts collected by applications can be distorted or even conflicting with each other. This is known as the context inconsistency problem. To provide reliable services, applications need to validate contexts before using them. One promising approach is to check contexts against consistency constraints at the runtime of applications. However, this can bring heavy computations due to tremendous amounts of contexts, thus leading to deteriorated performance to applications. Previous work has proposed incremental or concurrent checking techniques to improve the checking performance, but they heavily rely on CPU computing. In this paper, we propose a novel technique GAIN to exploit GPU computing to improve the checking performance. GAIN can automatically recognize parallel units in a constraint and schedule their checking in parallel on GPU cores. We evaluated GAIN with various constraints under different workloads. Our evaluation results show that, compared to CPU-based computing, GAIN saves CPU computing resources for pervasive applications while checks constraints much more efficiently.

Self-adaptive applications address environmental dynamics systematically. They can be faulty and exhibit runtime errors when environmental dynamics are not considered adequately. It becomes more severe when uncertainty exists in their sensing and adaptation to environments. Existing work verifies self-adaptive applications, but does not explicitly consider environmental constraints or uncertainty. This gives rise to inaccurate verification results. In this paper, we address this problem by proposing a novel approach to verifying self-adaptive applications suffering uncertainty in their environmental interactions. It builds Interactive State Machine (ISM) models for such applications and verifies them with explicit consideration of environmental constraints and uncertainty. It then refines verification results by prioritizing counterexamples according to their probabilities. We experimentally evaluated our approach with real-life self-adaptive applications, and the experimental results confirmed its effectiveness. Our approach reported 200-660% more counterexamples than not considering uncertainty, and eliminated all false counterexamples caused by ignoring environmental constraints.

Runtime reconfigurations of component-based systems must be undertaken with careful considerations of dependency between components. The safer and less disruptive a reconfiguration strategy is, the more accurate dependency information it needs. This paper proposes to manage dynamic dependency between components with mealy machine automatically derived from the implementation of components. To maintain the current dependency information for a component at runtime, the corresponding machine is instrumented into the component implementation in such a way that it is always synchronized with the execution of the component. We implemented a prototypical tool for this approach and evaluated it with a realistic benchmark application. The results show that our approach achieves a high accuracy and keeps low overheads without introducing any manual work.

Self-adaptive applications can easily contain faults. Existing approaches detect faults, but can still leave some undetected and manifesting into failures at runtime. In this paper, we study the correlation between occurrences of application failure and those of consistency failure. We propose fixing consistency failure to reduce application failure at runtime. We name this environment rematching, which can systematically reconnect a self-adaptive application to its environment in a consistent way. We also propose enforcing atomicity for application semantics during the rematching to avoid its side effect. We evaluated our approach using 12 self-adaptive robot-car applications by both simulated and real experiments. The experimental results confirmed our approach's effectiveness in improving dependability for all applications by 12.5-52.5%.

Practical software systems are subject to frequent updates for fixing their bugs or addressing new requirements. Updating a software system without stopping and restarting it is desired, as this helps reduce the redeployment cost as well as achieving the high availability. Existing techniques for dynamically updating Java programs may introduce noticeable pauses during which these programs are unable to function. We in this paper present Javelus, a dynamic Java update system with greatly reduced pausing time but without sacrificing update flexibility and system efficiency. Different from previous approaches, Javelus uses a lazy update mechanism with which an object-to-update will not be updated until it is really used. We implemented Javelus on top of an industry-strength OpenJDK HotSpot VM. We evaluated Javelus with real updates to Tomcat 7 and the same micro array benchmark used in evaluating Jvolve and DCE VM. The experiments report promising results that Javelus only incurred a pausing time two orders of magnitude smaller than those of Jvolve and DCE VM.

Self-adaptive systems are attractive due to their ability of adapting to changeable environments automatically. However, such systems may be subject to runtime failures when all environmental dynamics cannot be adequately considered at design time. When such failures occur at runtime, a system's internal adaptation logic usually has become inconsistent with its environment, according to our observation. We call this inconsistency sync-loss error. From our project experiences, we empirically identified a strong correlation between sync-loss error and system failure. This motivated us to fix sync-loss error in order to reduce failure for self-adaptive systems. In this paper, we formulate the problem of detecting sync-loss error, and present a framework ReSync to automatically fix sync-loss errors by desynchronizing a system with its environment. We experimentally evaluated ReSync on real robot cars with 20 different system versions. The evaluation reported promising results that ReSync can automatically recover our robot car systems from sync-loss errors, and significantly reduce the failure rate from 90.9% to 11.7-28.8%.

Detecting and resolving context inconsistency is critical to pervasive computing applications and infrastructures. Context inconsistency occurs when an application perceives contexts that breach predefined consistency constraints. This can drive an application to behave abnormally or even cause failure. Existing work commonly assumes the presence of a single application suffering from context inconsistency, such that specific repair actions can be taken to resolve the inconsistency for this application. However, when multiple applications run on the same infrastructure, they may impose conflicting requirements on resolving context inconsistency. In this paper, we propose a novel view-based approach ConsView to address such conflicting requirements. In ConsView, each application has a specific view to its own contexts that satisfy its own requirement on resolving context inconsistency. Such views are called consistent context views. We discuss the challenges of doing so and our ideas for addressing them. We implemented a prototype infrastructure supporting consistent context views, and evaluated it experimentally with simulated applications of real-life settings. The results confirmed the effectiveness and efficiency of our ConsView approach.

Internetware applications are context-aware and adaptive to their environmental changes. Faulty adaptation may arise when these applications face unexpected situations. Such adaptation faults can be difficult to detect at design time. The recent Adaptation Finite-State Machine (A-FSM) approach proposes to statically analyze model-based context-aware applications for adaptation faults. However, this approach may suffer expressiveness and precision problems. To address these limitations, we propose an Adaptation Model (AM) approach. As compared with A-FSM, AM offers increased expressive power to model complex rules, and guarantees soundness in fault detection. Besides, AM deploys an efficient rule evaluation technique to cater for context-aware applications that are subject to continual environmental changes. We evaluated our AM approach using both simulated and real-world experiments with two applications. The experimental results confirmed that AM can detect real faults missed by A-FSM, and avoid false positives that were misreported otherwise.

In this paper, we propose a Semi-UCS, which is an extension of the classical sUpervised Classifier System (UCS) [1] for semi-supervised learning tasks. A UCS works under a supervised learning scheme and uses only labeled data to train the system. In the Semi-UCS, we add an additional semi-supervised learning component to the original UCS, enablingthe LCS to learn from both labeled and unlabeled data. We provide three methods of how this semi-supervised learning component can be implemented: self-learning method, k-NN distance measure method and tri-training method. The Semi-UCS enlarges UCS's' application domains into semi-supervised settings and is a great addition to the LCS's model family. Experimental results on benchmark data sets of UCI repository have shown that Semi-UCS reaches a good performance for semi-supervised learning tasks.

Internetware is envisioned as a new software paradigm for resource integration and sharing in the open, dynamic and autonomous network environment. In this paper we discuss our visions and explorations of this new paradigm, with focus placed on the methodological perspective. A set of enabling techniques on flexible coordination of autonomous services, automatic adaptation to changing environment and trust management-based assurance of dependability are proposed to help the development of Internetware applications.

This demo displays the use of the prototypical ARTEMIS middleware system, which is developed at Nanjing University to support the construction, execution and evolution of applications in the open, dynamic and decentralized network environment of the Internet. To adapt to such a new environment, software application systems must be more flexible, more reactive, and more evolvable than before [1]. Built upon services from autonomous external sources, these application systems also have to explicitly consider the trustworthiness of the services. With these considerations, this version of ARTEMIS middleware is featured by its support for (1) multiple coordination modes based on various software architecture styles; (2) dynamic software architecture-based online reconfigurations, in reaction to the runtime changes in the environment and requirements; (3) trustworthiness evaluation at both the service level and the system level, which helps users to ensure and improve user's satisfaction on the system constructed.