Execution Engine Research Articles

Design and experimental evaluation of algorithms for optimizing the throughput of dispersed computing

We introduce three optimized scheduling algorithms for dispersed computing and present JupiterTP, a real-world system built on k8s and the prior Jupiter system, enabling end-to-end computation on distributed clusters. Distinguishing itself from traditional throughput optimization approaches that focus on theory and simulations, our work is the first implementation of such an end-to-end system capable of handling arbitrary DAGs across diverse computing networks, including public clouds, IoT systems, and edge networks. Beyond mere scheduling, JupiterTP integrates profilers, execution, and orchestration engines, offering unified interfaces for additional scheduling algorithm integrations. The system's performance is tested on real clusters and real applications, compared to prior work that relied on simulations alone. We make JupiterTP available to the community as open-source software at https://github.com/ANRGUSC/JupiterTP.

Scalable Cloud Execution Engines

Scalability remains a major concern for many organizations, and as technology evolves expeditiously, the number of users utilizing it also increases rapidly. In this paper, we propose a novel approach to address this challenge through the implementation of a scalable cloud execution engine using a microservices architecture. By using this design we can achieve a system with loosely coupled and independently deployable methods. Also through this, we can achieve enhanced flexibility, scalability, and reusability in our application. Through experimenting with various execution engines it is evident that most of their design relies on monolithic architecture. However, this design poses potential challenges especially when the traffic experiences sudden spikes. Our proposed design provides practical insights for architects and developers seeking to design and deploy highly scalable cloud applications.

HERALD: A domain-specific query language for longitudinal health data analytics

BackgroundLarge-scale health data has significant potential for research and innovation, especially with longitudinal data offering insights into prevention, disease progression, and treatment effects. Yet, analyzing this data type is complex, as data points are repeatedly documented along the timeline. As a consequence, extracting cross-sectional tabular data suitable for statistical analysis and machine learning can be challenging for medical researchers and data scientists alike, with existing tools lacking balance between ease-of-use and comprehensiveness. ObjectiveThis paper introduces HERALD, a novel domain-specific query language designed to support the transformation of longitudinal health data into cross-sectional tables. We describe the basic concepts, the query syntax, a graphical user interface for constructing and executing HERALD queries, as well as an integration into Informatics for Integrating Biology and the Bedside (i2b2). MethodsThe syntax of HERALD mimics natural language and supports different query types for selection, aggregation, analysis of relationships, and searching for data points based on filter expressions and temporal constraints. Using a hierarchical concept model, queries are executed individually for the data of each patient, while constructing tabular output. HERALD is closed, meaning that queries process data points and generate data points. Queries can refer to data points that have been produced by previous queries, providing a simple, but powerful nesting mechanism. ResultsThe open-source implementation consists of a HERALD query parser, an execution engine, as well as a web-based user interface for query construction and statistical analysis. The implementation can be deployed as a standalone component and integrated into self-service data analytics environments like i2b2 as a plugin. HERALD can be valuable tool for data scientists and machine learning experts, as it simplifies the process of transforming longitudinal health data into tables and data matrices. ConclusionThe construction of cross-sectional tables from longitudinal data can be supported through dedicated query languages that strike a reasonable balance between language complexity and transformation capabilities.

A Coq Mechanization of JavaScript Regular Expression Semantics

We present an executable, proven-safe, faithful, and future-proof Coq mechanization of JavaScript regular expression (regex) matching, as specified by the latest published edition of ECMA-262 section 22.2. This is, to our knowledge, the first time that an industrial-strength regex language has been faithfully mechanized in an interactive theorem prover. We highlight interesting challenges that arose in the process (including issues of encoding, corner cases, and executability), and we document the steps that we took to ensure that the result is straightforwardly auditable and that our understanding of the specification aligns with existing implementations. We demonstrate the usability and versatility of the mechanization through a broad collection of analyses, case studies, and experiments: we prove that JavaScript regex matching always terminates and is safe (no assertion failures); we identify subtle corner cases that led to mistakes in previous publications; we verify an optimization extracted from a state-of-the-art regex engine; we show that some classic properties described in automata textbooks and used in derivatives-based matchers do not hold in JavaScript regexes; and we demonstrate that the cost of updating the mechanization to account for changes in the original specification is reasonably low. Our mechanization can be extracted to OCaml and JavaScript and linked with Unicode libraries to produce an executable regex engine that passes the relevant parts of the official Test262 conformance test suite.

Composable Data Management: An Execution Overview

The trend of decomposing monolithic data management systems into a stack of reusable components has quickly gained momentum across the industry. Although a series of open-source projects have emerged targeting different layers of the stack, execution engines are of special importance due to the complexity they encapsulate, and the demand to optimize price-performance. In this tutorial, we will survey the space of composability in data management, focusing on the execution layer. We will discuss the main APIs, integration with existing and novel data management systems, and how specialized behavior can be accommodated by using extensibility APIs. With an emphasis on analytics, we will take a deeper dive into performance, discussing modern aspects of vectorization, compressed (encoding-aware) execution, and adaptivity. While the presentation is contextualized using real-world examples and experience while developing the Velox open-source execution engine and integrations with existing systems like Presto (Prestissimo) and Spark (Gluten), the concepts and techniques discussed are generally applicable to other execution engines. Finally, we will discuss future trends and ongoing work regarding novel file formats, compressed execution opportunities, and nascent hardware acceleration efforts, highlighting current challenges and open questions. With a survey of the state-of-the-art in this space, we hope this tutorial will help motivate individuals and organizations to embrace composability and promote collaborations across related projects.

Simple (yet Efficient) Function Authoring for Vectorized Engines

Vectorized execution engines process large datasets by decomposing computations into concise (tight) loops, which can be more efficiently executed by modern hardware. Providing loops that are optimal for execution usually adds burden to the software development process, as developers are required to understand details of vectorized execution, columnar data layout, data encodings, and the code compilation process itself, presenting a steep learning curve and challenges to organizations building and scaling large engineering teams. Due to their large quantity, scalar function authoring accentuates this problem. In our experience building the Velox open source execution engine, we have observed that exposing a large number of developers to the complexity inherent to vectorization resulted in a disproportionate amount of bugs and performance inefficiencies. In this paper, we describe the simple function interface (SFI) created to address this issue. SFI highly simplifies scalar function authoring by encapsulating the vectorization complexity required to generate tight loops, and presenting developers with a simpler, conciser, and more natural row-based interface - without sacrificing performance. SFI also hides columnar layout details, while providing developers the flexibility to efficiently implement advanced features such as functions with nested and recursive parameter types, type variables, variadic parameters, and generic types. Today, more than a thousand functions have been added to Velox using the SFI, implementing popular open source SQL dialects and internal domain-specific use cases at Meta, and are in active production use. While this paper presents implementation details, performance pitfalls, experimental results, and our overall experience developing the state-of-the-art Velox vectorized execution engine, we believe the concepts and trade-offs to be fundamentally equivalent and generally applicable to other vectorized engines.

ClickHouse - Lightning Fast Analytics for Everyone

Over the past several decades, the amount of data being stored and analyzed has increased exponentially. Businesses across industries and sectors have begun relying on this data to improve products, evaluate performance, and make business-critical decisions. However, as data volumes have increasingly become internet-scale, businesses have needed to manage historical and new data in a cost-effective and scalable manner, while analyzing it using a high number of concurrent queries and an expectation of real-time latencies (e.g. less than one second, depending on the use case). This paper presents an overview of ClickHouse, a popular open-source OLAP database designed for high-performance analytics over petabyte-scale data sets with high ingestion rates. Its storage layer combines a data format based on traditional log-structured merge (LSM) trees with novel techniques for continuous transformation (e.g. aggregation, archiving) of historical data in the background. Queries are written in a convenient SQL dialect and processed by a state-of-the-art vectorized query execution engine with optional code compilation. ClickHouse makes aggressive use of pruning techniques to avoid evaluating irrelevant data in queries. Other data management systems can be integrated at the table function, table engine, or database engine level. Real-world benchmarks demonstrate that ClickHouse is amongst the fastest analytical databases on the market.

CUPID: An efficient spatio-temporal data engine

In the IoT era, abundant spatio-temporal data is generated from various devices thanks to the prevalence of positioning techniques. Due to a lack of effective systems to manipulate the data, advanced scalable and efficient data management systems are necessary to support more and more urban applications.We propose Cupid, which is powered by scholars from Chongqing University and Guangzhou Urban Planning and Design Survey Research Institute, an efficient spatio-temporal Data engine. It extends JUST by introducing many functionalities to make it more applicable to deployment, and can efficiently manage large-scale spatio-temporal data. In Cupid, Apache HBase is utilized as the storage, GeoMesa serves as the spatio-temporal data indexing tool, and Apache Spark acts as the execution engine. We introduce many optimizations to ensure usability and reduce computational overhead. To make Cupid easy to use, we design and implement a SQL-like query language. Furthermore, to deploy the system as a PaaS while speeding up the execution, we leverage Apache Livy, a service that enables easy interaction with a Spark cluster over REST interfaces, together with gRPC to effectively collect results. Extensive experiments illustrate that Cupid outperforms other state-of-the-art spatio-temporal big data management systems in terms of efficiency and scalability.

ZARP: A user-friendly and versatile RNA-seq analysis workflow

Background RNA sequencing (RNA-seq) is a widely used technique in many scientific studies. Given the plethora of models and software packages that have been developed for processing and analyzing RNA-seq datasets, choosing the most appropriate ones is a time-consuming process that requires an in-depth understanding of the data, as well as of the principles and parameters of each tool. In addition, packages designed for individual tasks are developed in different programming languages and have dependencies of various degrees of complexity, which renders their installation and execution challenging for users with limited computational expertise. Workflow languages and execution engines with support for virtualization and encapsulation options such as containers and Conda environments facilitate these tasks considerably. The resulting computational workflows can then be reliably shared with the scientific community, enhancing reusability and the reproducibility of results as individual analysis steps are becoming more transparent and portable. Methods Here we present ZARP, a general purpose RNA-seq analysis workflow that builds on state-of-the-art software in the field to facilitate the analysis of RNA-seq datasets. ZARP is developed in the Snakemake workflow language and can run locally or in a cluster environment, generating extensive reports not only of the data but also of the options utilized. It is built using modern technologies with the ultimate goal to reduce the hands-on time for bioinformaticians and non-expert users and serve as a template for future workflow development. To this end, we also provide ZARP-cli, a dedicated command-line interface that may make running ZARP on an RNA-seq library of interest as easy as executing a single two-word command. Conclusions ZARP is a powerful RNA-seq analysis workflow that is easy to use even for beginners, built using best software development practices, available under a permissive Open Source license and open to contributions by the scientific community.

VM Matters: A Comparison of WASM VMs and EVMs in the Performance of Blockchain Smart Contracts

Beyond an emerging popular web applications runtime supported in almost all commodity browsers, WebAssembly (WASM) is further regarded to be the next-generation execution environment for blockchain-based applications. Indeed, many popular blockchain platforms such as EOSIO and NEAR have adopted WASM-based execution engines. Most recently, WASM has been favored by Ethereum, the largest smart contract platform, to replace the state-of-the-art EVM. However, whether and how well current WASM outperforms EVM on blockchain clients is still unknown. This article conducts the first measurement study to understand the performance on WASM VMs and EVM for executing smart contracts for blockchain-based applications. To our surprise, the current WASM VM does not provide expected satisfactory performance. The overhead introduced by WASM is really non-trivial. Our results shed the light on challenges when deploying WASM in practice, and provide insightful implications for improvement space.

LeCo: Lightweight Compression via Learning Serial Correlations

Lightweight data compression is a key technique that allows column stores to exhibit superior performance for analytical queries. Despite a comprehensive study on dictionary-based encodings to approach Shannon's entropy, few prior works have systematically exploited the serial correlation in a column for compression. In this paper, we propose LeCo (i.e., Learned Compression), a framework that uses machine learning to remove the serial redundancy in a value sequence automatically to achieve an outstanding compression ratio and decompression performance. LeCo presents a general approach to this end, making existing algorithms such as Frame-of-Reference (FOR), Delta Encoding, and Run-Length Encoding (RLE) special cases under our framework. Our microbenchmark with three synthetic and eight real-world data sets shows that a prototype of LeCo achieves a Pareto improvement on both compression ratio and random access speed over the existing solutions. When integrating LeCo into widely-used applications, we observe up to 5.2× speed up in a data analytical query in the Arrow columnar execution engine, and a 16% increase in RocksDB's throughput.

Repercussions of Using DNN Compilers on Edge GPUs for Real Time and Safety Critical Systems: A Quantitative Audit

Rapid advancements in edge devices have led to a large deployment of deep neural network (DNN) based workloads. To utilize the resources at the edge effectively, many DNN compilers are proposed that efficiently map the high level DNN models developed in frameworks like PyTorch, Tensorflow, Caffe, and so on into minimum deployable lightweight execution engines. For real time applications like ADAS, these compiler optimized engines should give precise, reproducible, and predictable inferences, both in-terms of runtime and output consistency. This article is the first effort in empirically auditing state-of-the-art DNN compilers viz TensorRT, AutoTVM, and AutoScheduler. We characterize the NN compilers based on their performance predictability w.r.t inference latency, output reproducibility, hardware utilization, and so on and based on that provide various recommendations. Our methodology and findings can potentially help the application developers, in making informed decision about the choice of DNN compiler, in a real time safety critical setting.

First implementation and results of the Analysis Grand Challenge with a fully Pythonic RDataFrame

First implementation and results of the Analysis Grand Challenge with a fully Pythonic RDataFrame

NeutronStream: A Dynamic GNN Training Framework with Sliding Window for Graph Streams

Existing Graph Neural Network (GNN) training frameworks have been designed to help developers easily create performant GNN implementations. However, most existing GNN frameworks assume that the input graphs are static, but ignore that most real-world graphs are constantly evolving. Though many dynamic GNN models have emerged to learn from evolving graphs, the training process of these dynamic GNNs is dramatically different from traditional GNNs in that it captures both the spatial and temporal dependencies of graph updates. This poses new challenges for designing dynamic GNN training frameworks. First, the traditional batched training method fails to capture real-time structural evolution information. Second, the time-dependent nature makes parallel training hard to design. Third, it lacks system supports for users to efficiently implement dynamic GNNs. In this paper, we present NeutronStream, a framework for training dynamic GNN models. NeutronStream abstracts the input dynamic graph into a chronologically updated stream of events and processes the stream with an optimized sliding window to incrementally capture the spatial-temporal dependencies of events. Furthermore, NeutronStream provides a parallel execution engine to tackle the sequential event processing challenge to achieve high performance. NeutronStream also integrates a built-in graph storage structure that supports dynamic updates and provides a set of easy-to-use APIs that allow users to express their dynamic GNNs. Our experimental results demonstrate that, compared to state-of-the-art dynamic GNN implementations, NeutronStream achieves speedups ranging from 1.48X to 5.87X and an average accuracy improvement of 3.97%.

Phoenix: A Live Upgradable Blockchain Client

Blockchain is an important supporting technology for various sustainable systems. It relies on a number of distributed nodes running blockchain client software, which is responsible for some critical tasks, such as communicating with other nodes and generating new blocks. However, the quick evolution of blockchain technology brings crucial challenges to blockchain client design. After carefully examining existing blockchain client software, we have identified a critical weakness: Blockchain clients are weak in supporting live upgrades, resulting in a blockchain fork that incurs security concerns and risks. In this paper, we propose Phoenix, a novel blockchain client design that is live upgradable. Phoenix uses blockchain service encapsulation to decouple blockchain services. Based on service encapsulation, we propose a live upgrade scheme that packs upgrade codes into blockchain transactions and uses a Just-In-Time engine to avoid service interruption. A parallel execution engine is developed to increase service efficiency. We evaluated Phoenix on a 51-node blockchain, and experimental results show that Phoenix outperforms existing solutions in overhead and upgrade latency.

Optimizing GPU-Based Graph Sampling and Random Walk for Efficiency and Scalability

Graph sampling and random walk algorithms are playing increasingly important roles today because they can significantly reduce graph size while preserving structural information, thus enabling computationally intensive tasks on large-scale graphs. Current frameworks designed for graph sampling and random walk tasks are generally not efficient in terms of memory requirement and throughput. Not to mention that some of them result in biased results. To solve the above problems, we introduce Skywalker+, a high-performance graph sampling and random walk framework on multiple GPUs supporting multiple algorithms. Skywalker+ makes four key contributions: First, it realizes highly paralleled alias method on GPUs. Second, it applies finely adjusted workload-balancing techniques and locality-aware execution modes to present a highly efficient execution engine. Third, it optimizes the GPU memory usage with efficient buffering and data compression schemes. Last, it scales to multi-GPU to further enhance the system throughput. Abundant experiments show that Skywalker+ exhibits significant advantage over the baselines both in performance and utility.

SWEL: A Domain-Specific Language for Modeling Data-Intensive Workflows

AbstractData-intensive applications aim at discovering valuable knowledge from large amounts of data coming from real-world sources. Typically, workflow languages are used to specify these applications, and their associated engines enable the execution of the specifications. However, as these applications become commonplace, new challenges arise. Existing workflow languages are normally platform-specific, which severely hinders their interoperability with other languages and execution engines. This also limits their reusability outside the platforms for which they were originally defined. Following the Design Science Research methodology, the paper presents SWEL (Scientific Workflow Execution Language). SWEL is a domain-specific modeling language for the specification of data-intensive workflows that follow the model-driven engineering principles, covering the high-level definition of tasks, information sources, platform requirements, and mappings to the target technologies. SWEL is platform-independent, enables collaboration among data scientists across multiple domains and facilitates interoperability. The evaluation results show that SWEL is suitable enough to represent the concepts and mechanisms of commonly used data-intensive workflows. Moreover, SWEL facilitates the development of related technologies such as editors, tools for exchanging knowledge assets between workflow management systems, and tools for collaborative workflow development.

XDB in Action: Decentralized Cross-Database Query Processing for Black-Box DBMSes

Data are naturally produced at different locations and hence stored on different DBMSes. To maximize the value of the collected data, today's users combine data from different sources. Research in data integration has proposed the Mediator-Wrapper (MW) architecture to enable ad-hoc querying processing over multiple sources. The MW approach is desirable for users, as they do not need to deal with heterogeneous data sources. However, from a query processing perspective, the MW approach is inefficient: First, one needs to provision the mediating execution engine with resources. Second, during query processing, data gets "centralized" within the mediating engine, which causes redundant data movement. Recently, we proposed in-situ cross-database query processing , a paradigm for federated query processing without a mediating engine. Our approach optimizes runtime performance and reduces data movement by leveraging existing systems, eliminating the need for an additional federated query engine. In this demonstration, we showcase XDB, our prototype for in-situ cross-database query processing. We demonstrate several aspects of XDB, i.e. the cross-database environment, our optimization techniques, and its decentralized execution phase.

USE OF MICRO-SERVICES ARCHITECTURE AND CONTAINERIZATION FOR THE FAST DEVELOPMENT AND TESTING OF THE CUBESAT NANOSATELLITES SOFTWARE

Abstract. CubeSats as a sub-class of nanosatellites have become a game-changer in the industry of scientific research and exploration of the new space technologies. Their cost effectiveness, relative ease of manufacturing, and predicted lifecycle are the main factors of success, leading to roughly 2280 nanosatellites being put on the Earth’s LEO. However, many issues still arise in regard to the effective development, testing, and successful mission control of the CubeSats. The authors of the article suggest the combination of well-known software development processes, design paradigms, patterns, and techniques, that are creating a new way of making CubeSat software development as flexible and as easy as possible. The very first part of the research suggests the outlook on modern software development processes and their evolution over the last years. The second part of the research looks into virtualization and containerization principles as the architectural response to complex software development. The third and fourth parts of the research concentrated on the selection and proper testing of the container execution engine and its performance with the most common algorithm used in embedded software development. Via the porting and proper performance test of the WASM3 WebAssembly interpreter, the authors provide valuable research in regard to the practical use of micro-services, and containerization in the CubeSats. For the sake of the usefulness and completeness of the porting and performance testing – the authors suggest the most-known STEM platforms as the test environments. Concluding the research by the practical porting and testing steps, and found limitations of the containerization, the authors come up with a newly defined concept of so-called Software Defined Satellites. Such a concept could help the industry to minimize risks in reusing the software, perform several missions on the same CubeSat spacecraft, and thus, drastically decrease the cost of CubeSats launches.

GraphTune: An Efficient Dependency-Aware Substrate to Alleviate Irregularity in Concurrent Graph Processing

With the increasing need for graph analysis, massive Concurrent iterative Graph Processing (CGP) jobs are usually performed on the common large-scale real-world graph. Although several solutions have been proposed, these CGP jobs are not coordinated with the consideration of the inherent dependencies in graph data driven by graph topology. As a result, they suffer from redundant and fragmented accesses of the same underlying graph dispersed over distributed platform, because the same graph is typically irregularly traversed by these jobs along different paths at the same time. In this work, we develop GraphTune , which can be integrated into existing distributed graph processing systems, such as D-Galois, Gemini, PowerGraph, and Chaos, to efficiently perform CGP jobs and enhance system throughput. The key component of GraphTune is a dependency-aware synchronous execution engine in conjunction with several optimization strategies based on the constructed cross-iteration dependency graph of chunks. Specifically, GraphTune transparently regularizes the processing behavior of the CGP jobs in a novel synchronous way and assigns the chunks of graph data to be handled by them based on the topological order of the dependency graph so as to maximize the performance. In this way, it can transform the irregular accesses of the chunks into more regular ones so that as many CGP jobs as possible can fully share the data accesses to the common graph. Meanwhile, it also efficiently synchronizes the communications launched by different CGP jobs based on the dependency graph to minimize the communication cost. We integrate it into four cutting-edge distributed graph processing systems and a popular out-of-core graph processing system to demonstrate the efficiency of GraphTune. Experimental results show that GraphTune improves the throughput of CGP jobs by 3.1∼6.2, 3.8∼8.5, 3.5∼10.8, 4.3∼12.4, and 3.8∼6.9 times over D-Galois, Gemini, PowerGraph, Chaos, and GraphChi, respectively.