Data-intensive Scalable Computing Research Articles

The Implementation of Titian for Data Provenance on DISC Systems Automated Debugging

Data-Intensive Scalable Computing (DISC) systems are critical for managing large datasets while prioritizing fault tolerance, cost effectiveness, and user accessibility. However, the presence of input errors in processed data presents considerable hurdles to programmers. The Snowfall Analysis program, which is well-known for its anomalous data that causes forecasting failures, serves as a key case study in this research. To solve this problem, this study leverages Titian, an extended library designed to speed debugging by methodically tracing the provenance of incorrect data back to its original source. Through thorough analysis, we analyzed Titian's accuracy using confusion matrix and compared its efficiency to standard manual debugging approaches, showing solid evidence of its utility in improving data provenance in DISC systems.

RelJoin: Relative-cost-based selection of distributed join methods for query plan optimization

Selecting appropriate distributed join methods for logical join operations in a query plan is crucial for the performance of data-intensive scalable computing (DISC). Different network communication patterns in the data exchange phase generate varying network communication workloads and significantly affect the distributed join performance. However, most cost-based query optimizers focus on the local computing cost and do not precisely model the network communication cost. We propose a cost model for various distributed join methods to optimize join queries in DISC platforms. Our method precisely measures the network and local computing workloads in different execution phases, using information on the size and cardinality statistics of datasets and cluster join parallelism. Our cost model reveals the importance of the relative size of the joining datasets. We implement an efficient distributed join selection strategy, known as RelJoin in SparkSQL, which is an industry-prevalent distributed data processing framework. RelJoin uses runtime adaptive statistics for accurate cost estimation and selects optimal distributed join methods for logical joins to optimize the physical query plan. The evaluation results on the TPC-DS benchmark show that RelJoin performs best in 62 of the 97 queries and can reduce the average query time by 21% compared with other strategies.1

SEIZE: Runtime Inspection for Parallel Dataflow Systems

Many Data-Intensive Scalable Computing (DISC) Systems provide easy-to-use functional APIs, and efficient scheduling and execution strategies allowing users to build concise data-parallel programs. In these systems, data transformations are concealed by exposed APIs, and intermediate execution states are masked under dataflow transitions. Consequently, many crucial features and optimizations (e.g., debugging, data provenance, runtime skew detection), which require runtime datafow states, are not well-supported. Inspired by our experience in implementing features and optimizations over DISC systems, we present SEIZE, a unified framework that enables dataflow inspection-wiretapping the data-path with listening logic-in MapReduce-style programming model. We generalize our lessons learned by providing a set of primitives defining dataflow inspection, orchestration options for different inspection granularities, and operator decomposition and dataflow punctuation strategy for dataflow intervention. We demonstrate the generality and flexibility of the approach by deploying SEIZE in both Apache Spark and Apache Flink, and by implementing a prototype runtime query optimizer for Spark. Our experiments show that, the overhead introduced by the inspection logic is most of the time negligible (less than 5 percent in Spark and 10 percent in Flink).

Capturing and Analyzing Provenance from Spark-based Scientific Workflows with SAMbA-RaP

Several scientists have moved their IO- and CPU-intensive workflows to Data-Intensive Scalable Computing (DISC) frameworks aiming at benefit from high scalability, broad support, and manufacturers’ infrastructure. A prominent framework is Apache Spark, which has been on an absolute tear over the last ten years and became one of the most widely used technologies in big data. Apache Spark brings several advantages along, as granting very efficient in-memory data management for large-scale applications through Resilient Distributed Datasets (RDDs). Such an in-memory replacement for MapReduce enables data handling activities of scientific workflows to be executed orders of magnitude faster in comparison to other DISC environments. A major drawback, however, is Apache Spark still lacks support for both data tracking and workflow provenance. Accordingly, the sole alternative for users that rely on provenance features is to spend countless hours collecting data from log files. Moreover, as one additional challenge, Apache Spark interprets legacy programs within workflows as “black-box” activities, which prevents the capture and analysis of data movements through RDDs. This manuscript presents the SAMbA-RaP (Spark provenAnce MAnagement with Reports and Presentation) solution for capturing, storing, and querying prospective and retrospective provenance, as well as domain data within distributed scientific workflows. SAMbA-RaP performance was evaluated upon real workflow cases (SciPhy, Montage, WordCount, BuzzFlow, and SalesForecasts) from distinct domains, e.g., literature, bioinformatics and astronomy, and results indicate the average imposed overhead for managing provenance data is acceptable. Moreover, experiments also indicate our solution is capable of handling workflows with and without legacy applications alike, which enables users to query and verify provenance data on SAMbA-RaP reports straightforwardly and transparently.

Cache-Based Multi-Query Optimization for Data-Intensive Scalable Computing Frameworks

In modern large-scale distributed systems, analytics jobs submitted by various users often share similar work, for example scanning and processing the same subset of data. Instead of optimizing jobs independently, which may result in redundant and wasteful processing, multi-query optimization techniques can be employed to save a considerable amount of cluster resources. In this work, we introduce a novel method combining in-memory cache primitives and multi-query optimization, to improve the efficiency of data-intensive, scalable computing frameworks. By careful selection and exploitation of common (sub)expressions, while satisfying memory constraints, our method transforms a batch of queries into a new, more efficient one which avoids unnecessary recomputations. To find feasible and efficient execution plans, our method uses a cost-based optimization formulation akin to the multiple-choice knapsack problem. Extensive experiments on a prototype implementation of our system show significant benefits of worksharing for both TPC-DS workloads and detailed micro-benchmarks.

Automated Debugging in Data-Intensive Scalable Computing.

Developing Big Data Analytics workloads often involves trial and error debugging, due to the unclean nature of datasets or wrong assumptions made about data. When errors (e.g., program crash, outlier results, etc.) arise, developers are often interested in identifying a subset of the input data that is able to reproduce the problem. BigSift is a new faulty data localization approach that combines insights from automated fault isolation in software engineering and data provenance in database systems to find a minimum set of failure-inducing inputs. BigSift redefines data provenance for the purpose of debugging using a test oracle function and implements several unique optimizations, specifically geared towards the iterative nature of automated debugging workloads. BigSift improves the accuracy of fault localizability by several orders-of-magnitude (~ 103 to 107×) compared to Titian data provenance, and improves performance by up to 66× compared to Delta Debugging, an automated fault-isolation technique. For each faulty output, BigSift is able to localize fault-inducing data within 62% of the original job running time.

Adding data provenance support to Apache Spark.

Debugging data processing logic in data-intensive scalable computing (DISC) systems is a difficult and time-consuming effort. Today's DISC systems offer very little tooling for debugging programs, and as a result, programmers spend countless hours collecting evidence (e.g., from log files) and performing trial-and-error debugging. To aid this effort, we built Titian, a library that enables data provenance-tracking data through transformations-in Apache Spark. Data scientists using the Titian Spark extension will be able to quickly identify the input data at the root cause of a potential bug or outlier result. Titian is built directly into the Spark platform and offers data provenance support at interactive speeds-orders of magnitude faster than alternative solutions-while minimally impacting Spark job performance; observed overheads for capturing data lineage rarely exceed 30% above the baseline job execution time.

Special Issue on Data-Intensive Scalable Computing Systems

Special Issue on Data-Intensive Scalable Computing Systems

Optimizing Interactive Development of Data-Intensive Applications.

Modern Data-Intensive Scalable Computing (DISC) systems are designed to process data through batch jobs that execute programs (e.g., queries) compiled from a high-level language. These programs are often developed interactively by posing ad-hoc queries over the base data until a desired result is generated. We observe that there can be significant overlap in the structure of these queries used to derive the final program. Yet, each successive execution of a slightly modified query is performed anew, which can significantly increase the development cycle. Vega is an Apache Spark framework that we have implemented for optimizing a series of similar Spark programs, likely originating from a development or exploratory data analysis session. Spark developers (e.g., data scientists) can leverage Vega to significantly reduce the amount of time it takes to re-execute a modified Spark program, reducing the overall time to market for their Big Data applications.

Titian

Debugging data processing logic in Data-Intensive Scalable Computing (DISC) systems is a difficult and time consuming effort. Today's DISC systems offer very little tooling for debugging programs, and as a result programmers spend countless hours collecting evidence (e.g., from log files) and performing trial and error debugging. To aid this effort, we built Titian, a library that enables data provenance-tracking data through transformations-in Apache Spark. Data scientists using the Titian Spark extension will be able to quickly identify the input data at the root cause of a potential bug or outlier result. Titian is built directly into the Spark platform and offers data provenance support at interactive speeds-orders-of-magnitude faster than alternative solutions-while minimally impacting Spark job performance; observed overheads for capturing data lineage rarely exceed 30% above the baseline job execution time.

Efficiency matters!

Current data intensive scalable computing (DISC) systems, although scalable, achieve embarrassingly low rates of processing per node. We feel that current DISC systems have repeated a mistake of old high-performance systems: focusing on scalability without considering efficiency. This poor efficiency comes with issues in reliability, energy, and cost. As the gap between theoretical performance and what is actually achieved has become glaringly large, we feel there is a pressing need to rethink the design of future data intensive computing and carefully consider the direction of future research.

Hadoop at home

The potential benefits of data-intensive scalable computing (DISC) in CS education are considered in the context of a small college with an active student-operated Beowulf cluster initiative. The map-reduce computational model, of great importance in industry, is reviewed, and the Hadoop implementation of that model is connected to specific courses throughout the undergraduate CS curriculum. Concerns when running a local Hadoop -capable cluster at a small college are identified.