Preview recommendations serve as a crucial shortcut for attracting users’ attention on various systems, platforms, and webpages, significantly boosting user engagement. However, the variability of preview types and the flexibility of preview duration make it challenging to use an integrated framework for multi-preview recommendations under resource constraints. In this paper, we present an approach that incorporates constrained Q-learning into a notification recommendation system, effectively handling both multi-preview ranking and duration orchestration by targeting long-term user retention. Our method bridges the gap between combinatorial reinforcement learning, which often remains too theoretical for practical use, and segmented modules in production, where model performance is typically compromised due to over-simplification. We demonstrate the superiority of our approach through off-policy evaluation and online A/B testing using Microsoft data.

Chinese ancient poetry has been a favorite literary genre for thousands of years. Nowadays, it is still read and ancient Chinese poets are honored. Recently, many websites provide automatic Chinese poetry generation service based on neural network. My research goal is to improve the quality of the poetry generation, i.e., making it as close as possible to the real poetry written by poets. To achieve this goal, I propose a new context-aware Chinese poetry generation method based on sequence-to-sequence framework. I generate a new concept called keyword team which is a combination of all the keywords to capture the context of the Chinese poetry. Then I use the keyword, the keyword team and the previously generated lines to generate the current line in a poem. I have already implemented the new context-aware Chinese poetry generation model called KPG (Keyword team based Poetry Generation). I have compared this method with state-of-the-art ones using loss function and human judgement. The comprehensive evaluation result show that our proposed method outperforms the state-of-the-art ones.

Scaling web applications such as e-commerce in cloud by adding or removing servers in the system is an important practice to handle workload variations, with the goal of achieving both high quality of service (QoS) and high resource efficiency. Through extensive scaling experiments of an n-tier application benchmark (RUBBoS), we have observed that scaling only hardware resources without appropriate adaptation of soft resource allocations (e.g., thread or connection pool size) of each server would cause significant performance degradation of the overall system by either under- or over-utilizing the bottleneck resource in the system. We develop a dynamic concurrency management (DCM) framework which integrates soft resource allocations into the system scaling management. DCM introduces a model which determines a near-optimal concurrency setting to each tier of the system based on a combination of operational queuing laws and online analysis of fine-grained measurement data. We implement DCM as a two-level actuator which scales both hardware and soft resources in an n-tier system on the fly without interrupting the runtime system performance. Our experimental results demonstrate that DCM can achieve significantly more stable performance and higher resource efficiency compared to the state-of-the-art hardware-only scaling solutions (e.g., Amazon EC2-AutoScale) under realistic bursty workload traces.

The performance of n-tier web-facing applications often suffer from response time long-tail problem. With relatively low resource utilization (less than 50%) and the majority of requests returning within a few milliseconds, a non-negligible num-ber of normally short requests may take seconds to return. We propose the millibottleneck theory of performance bugs (that lead to long-tail problems). Several case studies have confirmed the millibottlenecks (that last a few tens to hundreds of milliseconds) as causal agents of long requests. A concrete example (garbage collection) illustrates the experimental verification of millibottlenecks. An open source fine-grain monitoring toolkit is being devel-oped to facilitate the experimental research on millibottlenecks.

Virtualization-based multi-tenant database consolidation is an important technique for database-as-a-service (DBaaS) providers to minimize their total cost which is composed of SLA penalty cost, infrastructure cost and action cost. Due to the bursty and diverse tenant workloads, over-provisioning for the peak or under-provisioning for the off-peak often results in either infrastructure cost or service level agreement (SLA) penalty cost. Moreover, although the process of scaling out database systems will help DBaaS providers satisfy tenants' service level agreement, its indiscriminate use has performance implications or incurs action cost. In this paper, we propose SmartSLA, a cost-sensitive virtualized resource management system for CPU-bound database services which is composed of two modules. The system modeling module uses machine learning techniques to learn a model for predicting the SLA penalty cost for each tenant under different resource allocations. Based on the learned model, the resource allocating module dynamically adjusts the resource allocation by weighing the potential reduction of SLA penalty cost against increase of infrastructure cost and action cost. SmartSLA is evaluated by using the TPC-W and modified YCSB benchmarks with dynamic workload trace and multiple database tenants. The experimental results show that SmartSLA is able to minimize the total cost under time-varying workloads compared to the other cost-insensitive approaches.

Nowadays data analytics applications are accessing more and more data from distributed data stores, creating a large amount of data traffic on the network. Therefore, distributed analytic queries are prone to suffer from poor performance when they encounter network contention, which can be quite common in a shared network. Typical distributed query optimizers do not have a way to solve this problem because they treat the network as a black-box: they are unable to monitor it, let alone control it. With the new era of software-defined networking (SDN), we show how SDN can be effectively exploited for performance management for analytical queries in distributed data store environments. More specifically, we present a group of methods to leverage SDN's visibility into and control of the network's state that enable distributed query processors to achieve performance improvements and differentiation for analytical queries. We demonstrate the effectiveness of the methods through detailed experimental studies on a system running on a software-defined network with commercial switches. To the best of our knowledge, this is the first work to analyze and show the opportunities of SDN for distributed query optimization. It is our hope that this will open up a rich area of research and technology development in distributed data intensive computing.

Nowadays data analytics applications are accessing more and more data from distributed data stores, creating large amount of data traffic on the network. Therefore, distributed analytic queries are prone to suffer from bad performance in terms of query execution time when they encounter a network resource contention, which is quite common in a shared network. Typical distributed query optimizers do not have a way to solve this problem because historically they have been treating the network underneath as a black-box: they are unable to monitor it, let alone to control it. However, we are entering a new era of software-defined networking (SDN), which provides visibility into and control of the network's state for the applications including distributed database systems. In this demonstration, we present a system, called Pronto that leverages the SDN capabilities for a distributed query processor to achieve performance improvement and differentiation for analytical queries. The system is the real implementation of our recently developed methods on commercial SDN products. The demonstration shows the shortcomings of a distributed query optimizer, which treats the underlying network as a black box, and the advantages of the SDN-based approach by allowing the users to selectively explore various relevant and interesting settings in a distributed query processing environment.

Many business customers hesitate to move all their applications to the cloud due to performance concerns. White-box diagnosis relies on human expert experience or performance troubleshooting "cookbooks" to find potential performance bottlenecks. Despite wide adoption, the scalability and adaptivity of such approaches remain severely constrained, especially in a highly-dynamic, consolidated cloud environment. Leveraging the rich telemetry collected from applications and systems in the cloud, and the power of statistical learning, vPerfGuard complements the existing approaches with a model-driven framework by: (1) automatically identifying system metrics that are most predictive of application performance, and (2) adaptively detecting changes in the performance and potential shifts in the predictive metrics that may accompany such a change. Although correlation does not imply causation, the predictive system metrics point to potential causes that can guide a cloud service provider to zero in on the root cause.

Such concurrent systems as Web services and workflow systems can be viewed as a composition of a set of subsystems. Subsystems interact with each other through a set of message channels in order to perform a task. This work defines a class of Petri nets called interactive Petri nets (IPNs) to model these systems. IPNs can be used to analyze their behavior, find potential problems, and then improve their designs. Compatibility is an important concept for a composed system and reflects the possibility of correct/proper interaction among its subsystems. In order to characterize different cooperative abilities in practice, compatibility and weak compatibility are defined for IPNs. Some relationships among (weak) compatibility, liveness, reversibility, and boundedness are revealed. Based on them, this work proves that the (weak) compatibility problem is co-NP-hard. A taxonomy is also presented for IPNs in order to explore whether some subclasses can be analyzed efficiently. Based on it, we can identify several IPN subclasses, some of which can be analyzed in polynomial time.

Recently, mediation-aided composition has been widely adopted when dealing with incompatibilities of services. However, existing approaches suffer from state space explosion in compatibility verification and cannot automatically generate the BPEL code. This paper presents a Petri net approach to mediation-aided composition of Web services. First, services are modeled as open WorkFlow Nets (oWFNs) and are composed using mediation transitions (MTs). Second, the modular reachability graph (MRG) of composition is automatically constructed and the compatibility is analyzed, so that the problem of state space explosion is significantly alleviated. Furthermore, an Event-Condition-Action (ECA) rule-based technique is developed to automatically generate the BPEL code of the composition, which can significantly save the time and labor of designers. Finally, the prototype system has been developed.

The increasing popularity of computing clouds continues to drive both industry and research to provide answers to a large variety of new and challenging questions. We aim to answer some of these questions by evaluating performance and scalability when an n-tier application is migrated from a traditional datacenter environment to an IaaS cloud. We used a representative n-tier macro-benchmark (RUBBoS) and compared its performance and scalability in three different test beds: Amazon EC2, Open Cirrus (an open scientific research cloud), and Emulab (academic research test bed). Interestingly, we found that the best-performing configuration in Emulab can become the worst-performing configuration in EC2. Subsequently, we identified the bottleneck components, high context switch overhead and network driver processing overhead, to be at the system level. These overhead problems were confirmed at a finer granularity through micro-benchmark experiments that measure component performance directly. We describe concrete alternative approaches as practical solutions for resolving these problems.

The system overload is a common problem in a Database-as-a-Serice (DaaS) environment because of unpredictable and bursty workloads from various clients. Due to the service delivery nature of DaaS, such system overload usually has direct economic impact on the service provider, who has to pay penalties if the system performance does not meet clients' service level agreements (SLAs). In this paper, we investigate techniques that prevent system overload by using admission control. We propose a profit-oriented admission control framework, called ActiveSLA, for DaaS providers. ActiveSLA is an end-to-end framework that consists of two components. First, a prediction module estimates the probability for a new query to finish the execution before its deadline. Second, based on the predicted probability, a decision module determines whether or not to admit the given query into the database system. The decision is made with the profit optimization objective, where the expected profit is derived from the service level agreements between a service provider and its clients. We present extensive real system experiments with standard database benchmarks, under different traffic patterns, DBMS settings, and SLAs. The results demonstrate that ActiveSLA is able to make admission control decisions that are both more accurate and more profit-effective than several state-of-the-art methods.

Resource provisioning for N-tier web applications in Clouds is non-trivial due to at least two reasons. First, there is an inherent optimization conflict between cost of resources and Service Level Agreement (SLA) compliance. Second, the resource demands of the multiple tiers can be different from each other, and varying along with the time. Resources have to be allocated to multiple (virtual) containers to minimize the total amount of resources while meeting the end-to-end performance requirements for the application. In this paper we address these two challenges through the combination of the resource controllers on both application and container levels. On the application level, a decision maker (i.e., an adaptive feedback controller) determines the total budget of the resources that are required for the application to meet SLA requirements as the workload varies. On the container level, a second controller partitions the total resource budget among the components of the applications to optimize the application performance (i.e., to minimize the round trip time). We evaluated our method with three different workload models -- open, closed, and semi-open - that were implemented in the RUBiS web application benchmark. Our evaluation indicates two major advantages of our method in comparison to previous approaches. First, fewer resources are provisioned to the applications to achieve the same performance. Second, our approach is robust enough to address various types of workloads with time-varying resource demand without reconfiguration.

In a cloud computing environment, resources are shared among different clients. Intelligently managing and allocating resources among various clients is important for system providers, whose business model relies on managing the infrastructure resources in a cost-effective manner while satisfying the client service level agreements (SLAs). In this paper, we address the issue of how to intelligently manage the resources in a shared cloud database system and present SmartSLA, a cost-aware resource management system. SmartSLA consists of two main components: the system modeling module and the resource allocation decision module. The system modeling module uses machine learning techniques to learn a model that describes the potential profit margins for each client under different resource allocations. Based on the learned model, the resource allocation decision module dynamically adjusts the resource allocations in order to achieve the optimum profits. We evaluate SmartSLA by using the TPC-W benchmark with workload characteristics derived from real-life systems. The performance results indicate that SmartSLA can successfully compute predictive models under different hardware resource allocations, such as CPU and memory, as well as database specific resources, such as the number of replicas in the database systems. The experimental results also show that SmartSLA can provide intelligent service differentiation according to factors such as variable workloads, SLA levels, resource costs, and deliver improved profit margins.

Good performance and efficiency, in terms of high quality of service and resource utilization for example, are important goals in a cloud environment. Through extensive measurements of an n-tier application benchmark (RUBBoS), we show that overall system performance is surprisingly sensitive to appropriate allocation of soft resources (e.g., server thread pool size). Inappropriate soft resource allocation can quickly degrade overall application performance significantly. Concretely, both under-allocation and over-allocation of thread pool can lead to bottlenecks in other resources because of non-trivial dependencies. We have observed some non-obvious phenomena due to these correlated bottlenecks. For instance, the number of threads in the Apache web server can limit the total useful throughput, causing the CPU utilization of the C-JDBC clustering middleware to decrease as the workload increases. We provide a practical iterative solution approach to this challenge through an algorithmic combination of operational queuing laws and measurement data. Our results show that soft resource allocation plays a central role in the performance scalability of complex systems such as n-tier applications in cloud environments.

Current methods that deal with concurrent workflow temporal violations only focus on checking whether there are any temporal violations. They are not able to point out the path where the temporal violation happens and thus cannot provide specific solutions. This paper presents an approach based on a sprouting graph to find out the temporal violation paths in concurrent workflow processes as well as possible solutions to resolve the temporal violations. First, we model concurrent workflow processes with time workflow net and a sprouting graph. Second, we update the sprouting graph at the checking point. Finally, we find out the temporal violation paths and provide solutions. We apply the approach in a real business scenario to illustrate its advantages: 1) It can dynamically check temporal constraints of multiple concurrent workflow processes with resource constraints; 2) it can give the path information in the workflow processes where the temporal violation happens; and 3) it can provide solution to the temporal violation based on the analysis.

Control theory has been utilized in recent years to manage the resources in virtualized environment for applications with time-varying resource demand. The systems under control, including the servers and the applications, are taken as black-boxes, and the controllers are generally expected to be adaptive to the underline systems. However, little attention has been paid to the behaviors of the applications themselves, and most of time, single performance target such as the mean response time threshold has been tracked. In this paper, we experimentally show that more than one performance metrics have to be considered to characterize the quality of service that the end users receive when the performance is managed through dynamic resource allocation. Moreover, the behavior of the applications, especially that of the workload generators has significant effect on the quality of the service. Our study provides insights and guidance for end-to-end performance management problem in virtualized environment.

Business process execution language for Web services (BPEL) is becoming the industrial standard for modeling Web-service-based business processes. Behavioral compatibility for Web service composition is one of the most important topics. The commonly used reachability exploration method focuses on verifying deadlock freeness. When this property is violated, the states and traces in the reachability graph only give clues to redesign the composition. The redesign must then repeat itself until no deadlock is found. In this paper, multiple Web service interaction is modeled with a Petri net called composition net (C-net for short). The problem of behavioral compatibility among Web services is hence transformed into the deadlock structure problem of a C-net. If services are incompatible, a policy based on appending additional information channels is proposed. It is proved that the policy can offer a good solution that can be mapped back into the BPEL models automatically.

Protocol-level mismatch is one of the most important problems in service composition. The commonly used reachability exploration method focuses on verifying deadlock-freeness. When this property is violated, the states and traces in the reachability graph only give clues to re-design the composition. The process must then repeat itself until no deadlock is found. In this paper, multiple Web service interaction is modeled with a Petri net called composition net (C-net). The protocol-level mismatch problem is transformed into the deadlock structure problem of a C-net. If mismatches are found, a solution based on Petri net siphons is proposed. The proposed method is shown to achieve higher efficiency for resolving protocol-level mismatching issues than traditional ones do.

With the popularity of Internet technology, Web services are becoming the most promising paradigm for distributed computing. However, when a single Web service fails to meet service requestor's multiple function needs, web services need to be dynamically configured together to form a web service composition. Since there may be many configurations providing identical functionality with different quality-of-service (QoS), a choice needs to be made according to users' functional and nonfunctional requirements. In this paper, we formulate a Web service functional configuration problem by using Petri nets. The graph structure and algebraic properties of the model are analyzed in detail to show that a basis solution of a state-shift equation of the Petri net model corresponds to a realizable configuration process. This result is later used to formulate the multiple attribute QoS optimization problem to a linear programming problem. Finally, a case study is performed to show that the proposed analysis result can be effectively applied in practice.

With the development of enterprise-wide and cross-enterprise application integration and interoperation toward Web service, Web service providers try to not only fulfill the functional requirements of Web service users but also satisfy their nonfunctional conditions in order to survive in the competitive market. A hot research topic is how to configure Web services to meet their demand when the diversity of user requirements, distinction of service components' performance, and limitation of resources are considered. This paper builds a Web service configuration net based on Petri nets in order to exhibit Web service configurations in a formal way. Then, an optimal algorithm is presented to help choose the best configuration with the highest quality of service to meet users' nonfunctional requirements. Finally, the simulation results and related analysis prove the soundness and correctness of our model and algorithm.

With the development of enterprise-wide and cross-enterprise application integration and interoperation towards web service, web service providers try to not only fulfill the functional requirements of web service users, but also satisfy their non-functional conditions in order to survive in the competitive market. A hot research topic is how to configure web services to meet their demand under a dynamic heterogeneous environment. This paper builds a web service configuration net based on Petri nets in order to exhibit web service configuration in a formal way. Then, an optimal algorithm is presented to help choose the best configuration with the highest quality of services (QoS) to meet users’ non-functional requirements. Finally, the simulation results and related analysis prove the soundness and correctness of our model and algorithm.