Image vectorization aims to convert raster images to vector ones, allowing for easy scaling and editing. Existing works mainly rely on preset parameters (i.e., a fixed number of paths and control points), ignoring the complexity of the image and posing significant challenges to practical applications. We demonstrate that such an assumption is often incorrect, as the preset paths or control points may be neither essential nor enough to achieve accurate and editable vectorization results. Based on this key insight, in this paper, we propose AdaVec, an efficient image vectorization method with adaptive parametrization, where the paths and control points can be adjusted dynamically based on the complexity of the input raster image. In particular, we first decompose the input raster image into a set of pure-colored layers that are aligned with human perception. For each layer with varying shape complexity, we propose a novel allocation mechanism to adaptively adjust the control point distribution. We further adopt a differentiable rendering process to compose and optimize the shape and color parameters of each layer iteratively. Extensive experiments demonstrate that AdaVec outperforms the baselines qualitatively and quantitatively, in terms of computational efficiency, vectorization accuracy, and editing flexibility.

Cloud or distributed storage systems characterized by high data redundancy necessitate effective data reduction techniques to reduce storage costs. Post-deduplication delta compression has proven effective by eliminating both duplicated and similar yet non-duplicated chunks. However, existing approaches often rely on fixed-feature matching for resemblance detection, which, while fast, may lead to lower reduction ratios and not robust benefits across various datasets. In this paper, we introduce BePro, a novel system that integrates Flexible Feature Matching (§IV-A) to achieve better benefits in post-deduplication delta compression. BePro employs Gain Filtering (§IV-B) to identify high-gain chunks while discarding low-gain similar chunks, ensuring robust benefits across different datasets. Additionally, BePro implements a new indexing structure, LSH-Delta (§IV-C), to search for similar chunks and utilizes Index Load Balancer (§IV-D) for efficient resemblance detection by exploiting the distribution characteristics of similar chunks. Furthermore, the Index Manager (§IV-E) skillfully manages memory space overhead, ensuring memory efficiency. We implemented a pipeline prototyping framework to facilitate the evaluation of BePro and other leading techniques. Extensive experiments demonstrate that BePro improves the data-reduction ratios by up to$1.15 \times-2.35 \times$while achieving comparable speed.

Many modern software systems provide numerous configuration options with a large parameter space that users can adjust for specific running environments. However, configuring such systems always incurs an undue burden on users due to the lack of domain knowledge to understand complex interactions between the performance and the parameters. To address this issue, various tuning techniques have been developed to automatically determine the optimal configuration by either directly searching the configuration space or learning a surrogate model to guide the exploration process. Most previous studies only apply simple search strategies to explore the complex configuration space , which often leads to fruitless attempts in suboptimal areas. Inspired by previous studies, we define configuration structures to describe the positions of various configurations in the performance space of software systems. This idea leads to the design of a novel Configuration Structure-Aware Tuning (CSAT) algorithm. CSAT constructs a structure model for system configurations using the framework of Adaptive Network-based Fuzzy Inference System (ANFIS), learns a comparison-based distribution model through Gaussian Process Regression (GPR), and uses Bayesian Inference to generate potentially promising configurations based on the structure. The experimental results demonstrate that in terms of tuning performance, on average, CSAT outperforms default configurations by 65.51% and outperforms six state-of-the-art tuning algorithms by 22.10%–33.20%. In terms of handling internal constraints, CSAT achieves an average probability of 0.767 in generating valid configurations.

Deep learning (DL) has become a dominating type of workloads on AI computing platforms. The performance of such platforms highly depends on how distributed DL jobs are scheduled. Reinforcement learning (RL)-based schedulers have been extensively studied and are capable of modeling interferences between concurrent jobs competing for resources. However, existing RL-based schedulers must learn from large number of samples and adapt to workload changes in real systems, which is a huge cost for production clusters. This paper proposes an intelligent, autonomous scheduler that employs sample-efficient RL for real-world resource scheduling on complex DL clusters. Specifically, we design a closed-loop meta-RL-based worker placement algorithm for DL training jobs. Instead of random exploration, we encourage the scheduler to explore combinatorial subspaces, where the performance model might be inaccurate, to improve the sampling efficiency of the scheduler agent. Extensive experimental results demonstrate that our algorithm outperforms other baselines in terms of average job completion time with 12.29% to 16.24% improvements. Further experiments with workload variations yield 15.76% to 22.13% improvements.

When several Web services with simple functions need to be combined to provide more complex functions, how to choose from a large number of Web services with the same functions but different quality of service is a QoS-based service composition problem. Currently, there are many classical methods and reinforcement learning methods applied to the QoS-based service composition problem. However, these methods require long computation time. We address three challenges in building an end-to-end supervised learning framework. 1) The number of Web services composing different composite services varies. 2) The topological relationships among Web services are difficult to express and difficult to integrate into neural networks. 3) The number of Web services providing each sub-function in composite services varies. Finally, we propose DeepQSC, a deep supervised learning framework based on graph convolutional networks and attention mechanisms. The framework can form high QoS composite services with limited computation time. We conducted experiments on a real-world dataset. The experiments show that DeepQSC has a significant advantage over six current state-of-the-art algorithms.

Complex software systems often provide a large number of parameters so that users can configure them for their specific application scenarios. However, configuration tuning requires a deep understanding of the software system, far beyond the abilities of typical system users. To address this issue, many existing approaches focus on exploring and learning good performance estimation models. The accuracy of such models often suffers when the number of available samples is small, a thorny challenge under a given tuning-time constraint. By contrast, we hypothesize that good configurations often share certain hidden structures. Therefore, instead of trying to improve the performance estimation of a given configuration, we focus on capturing the hidden structures of good configurations and utilizing such learned structure to generate potentially better configurations. We propose ACTGAN to achieve this goal. We have implemented and evaluated ACTGAN using 17 workloads with eight different software systems. Experimental results show that ACTGAN outperforms default configurations by 76.22% on average, and six state-of-the-art configuration tuning algorithms by 6.58%-64.56%. Furthermore, the ACTGAN-generated configurations are often better than those used in training and show certain features consisting with domain knowledge, both of which supports our hypothesis.

Microservice has been increasingly recognized as a promising architectural style for constructing large-scale cloud-based applications within and across organizational boundaries. This microservice-based architecture greatly increases application scalability, but meanwhile incurs an expensive performance overhead, which calls for a careful design of performance modeling and task scheduling. However, these problems have thus far remained largely unexplored. In this paper, we develop a performance modeling and prediction method for independent microservices, design a three-layer performance model for microservice-based applications, formulate a Microservice-based Application Workflow Scheduling problem for minimum end-to-end delay under a user-specified Budget Constraint (MAWS-BC), and propose a heuristic microservice scheduling algorithm. The performance modeling and prediction method are validated and justified by experimental results generated through a well-known microservice benchmark on disparate computing nodes, and the performance superiority of the proposed scheduling solution is illustrated by extensive simulation results in comparison with existing algorithms.

Big data analytics frameworks (BDAFs) have been widely used for data processing applications. These frameworks provide a large number of configuration parameters to users, which leads to a tuning issue that overwhelms users. To address this issue, many automatic tuning approaches have been proposed. However, it remains a critical challenge to generate enough samples in a high-dimensional parameter space within a time constraint. In this paper, we present AutoTune-an automatic parameter tuning system that aims to optimize application execution time on BDAFs. AutoTune first constructs a smaller-scale testbed from the production system so that it can generate more samples, and thus train a better prediction model, under a given time constraint. Furthermore, the AutoTune algorithm produces a set of samples that can provide a wide coverage over the high-dimensional parameter space, and searches for more promising configurations using the trained prediction model. AutoTune is implemented and evaluated using the Spark framework and HiBench benchmark deployed on a public cloud. Extensive experimental results illustrate that AutoTune improves on default configurations by 63.70% on average, and on the five state-of-the-art tuning algorithms by 6%-23%.

Parallel computing combined with distributed data storage and management has been widely adopted by most big data analytics systems. Scheduling computing tasks to improve data locality is crucial to the performance of such systems. While existing schedulers target near-data scheduling on top of physical data blocks, these systems face a new scheduling problem where computing tasks process table-based datasets directly and access large physical blocks indirectly through their indices stored in associated small logical blocks. This new problem invalidates the basic assumption made by many existing algorithms on near-data scheduling. In this paper, we propose a Logical-block Affinity Scheduling (LAS) algorithm to coordinate the near-data scheduling of computing tasks and the placement of logical blocks for a desired balance between data-locality and load-balancing to maximize system throughput. The proposed algorithm is implemented and evaluated using a well-known big data benchmark and a practical production system deployed in public clouds. Extensive experimental results illustrate the performance superiority of LAS over three existing scheduling algorithms.

Distributed message systems (DMSs) serve as the communication backbone for many real-time streaming data processing applications. To support the vast diversity of such applications, DMSs provide a large number of parameters to configure. However, It overwhelms for most users to configure these parameters well for better performance. Although many automatic configuration approaches have been proposed to address this issue, critical challenges still remain: 1) to train a better and robust performance prediction model using a limited number of samples, and 2) to search for a high-dimensional parameter space efficiently within a time constraint. In this paper, we propose AutoConfig -- an automatic configuration system that can optimize producer-side throughput on DMSs. AutoConfig constructs a novel comparison-based model (CBM) that is more robust that the prediction-based model (PBM) used by previous learning-based approaches. Furthermore, AutoConfig uses a weighted Latin hypercube sampling (wLHS) approach to select a set of samples that can provide a better coverage over the high-dimensional parameter space. wLHS allows AutoConfig to search for more promising configurations using the trained CBM. We have implemented AutoConfig on the Kafka platform, and evaluated it using eight different testing scenarios deployed on a public cloud. Experimental results show that our CBM can obtain better results than that of PBM under the same random forests based model. Furthermore, AutoConfig outperforms default configurations by 215.40% on average, and five state-of-the-art configuration algorithms by 7.21%-64.56%.

Service composition has been proven to be a convincing computing paradigm for rapidly constructing large-scale distributed applications within and across organizational boundaries. Quality of service (QoS)-aware service composition, i.e. selection of the optimal execution plan that maximizes the composition's end-to-end QoS properties, is an active area of research and development endeavors in service composition. In this article, we propose an orthogonal genetic algorithm (OGA) for QoS-aware service composition problem. Its significant feature is to incorporate an orthogonal design method into the initial population generation process and crossover operation. As a result, our algorithm is more robust and can search the solution space in a statistically sound manner. We have executed the OGA to solve 81 randomly generated service composition problems with different sizes and structures based on QWS data set including 2507 real Web services. The results indicate that our OGA can find near-optimal solutions within moderate numbers of generation and has the performance superiority in comparison with many existing optimization algorithms.

With the prevalence of SOA, an increasing number of Web services are created and composed to construct complex business processes. Selecting an appropriate service from a lot of independently developed services which have the same functionality but different QoS properties is essential for the effect of the composite service according to users' preference. Moreover, the efficiency and effect of the service selection algorithm also play an important role. In this paper, we propose a novel algorithm, named QSSAC, for service selection problem. This algorithm is based on the service clustering which can cluster a lot of atomic services of each task into a few classes according to their QoS properties. With the help of service clustering, our algorithm is able to reduce the execution time and guarantee the near-optimal result as well. Finally, three strategies are provided for re-selecting atomic services in dynamic environment. In experiment, we study the performance of QSSAC algorithm, and its feasibility has been demonstrated by simulation.

Migrating legacy object-oriented system functionalities to SOA environment is a important problem that frequently arises in many system maintenance and integration tasks. A service is often implemented by complex collaborations of many objects in an object-oriented system. Such complexity brings impedance mismatch between service and object. Moreover, the delocalized nature of object-oriented system, where the code associated with a service is distributed across many interrelated objects, make this problem even more challenging. This paper presents a four-staged approach that extracts services from legacy object-oriented systems with source code and documents. In the first stage source code of legacy system is loaded and preprocessed to form different modules according to the explicit dependencies among classes. While preprocessing, some aspect code is also embedded to intercept and log execution traces of system as well as to store states of involved objects. In the second stage, services, which represent system-level business functionalities, are modeled with use cases. Useful test cases are in turn generated from these use cases to identify services. In the third stage, the modularized and intercepted system is executed driven by generated test cases and the execution logs and object states are recorded. In the last stage, services are located and extracted by analyzing the execution logs and restoring the object states. The approach is supported by an integrated tool and the evaluation on five open-source systems yields encouraging result and demonstrates the practical applicability of the approach.

Despite the great momentum gained about the testing, analysis and verification of BPEL process, little attention has paid to the debugging issues, especially about the building of ad hoc debuggers. In this paper, we propose and implement RBDB (reversible BPEL debugger), a specially made reversible debugger for BPEL process. RBDB is built on the abstract debugging APIs to fulfill its functionality. A reversible concurrent debugging model and three strategies to handle different type of external Web services are introduced later. Finally, a comprehensive analysis of experiment data are presented. Evaluation results demonstrate that RBDB can improve users' efficiency significantly and decrease the invoking times of external services substantially.