Predicting Intermediate Storage Performance for Workflow Applications

Predicting Intermediate Storage Performance for Workflow Applications

Abstract

System provisioning, resource allocation, and system configuration decisions for workflow I/O-intensive applications are complex even for expert users. One factor making the problem space more complex is that users face decisions at multiple levels: allocating resources to individual sub-systems (e.g., the application layer, the storage layer) and configuring each of these optimally (e.g., replication level, chunk size, caching policies in case of storage) which have a large impact on overall application performance.

This paper presents our progress on addressing the problem of supporting these provisioning, allocation and configuration decisions for workflow applications. To enable selecting a good choice in a reasonable time, we propose an approach that accelerates the exploration of the configuration space based on a low-cost performance predictor that estimates total execution time of a workflow application in a given setup. The evaluation shows that we are on a good track to meet our objectives: our performance predictor can scale to model a workflow application run on an entire cluster while offering an over 200x speedup compared to running the actual application, and can achieve, in the limited number of scenarios we study, a prediction accuracy that enables identifying the best storage system configuration.

1 Introduction

Assembling workflow applications by putting together standalone binaries has become a popular approach to support large-scale science (e.g., modFTDock [1], Montage[2] or BLAST [3]). The processes spawned from these binaries communicate via temporary files stored on a shared storage system. In this setup, the workflow runtime engines are basically schedulers that build and manage a task-dependency graph based on the tasks’ input/output files (e.g., SWIFT [4], Pegasus [5]).

To avoid accessing the platform’s backend storage system (e.g., NFS or GPFS or Amazon S3), recent proposals (e.g., [6, 7]) advocate using some of the nodes allocated to the application to deploy a intermediate storage system. That is, aggregating (some of) the resources of an application allocation to provide a shared temporary storage system dedicated to (and co-deployed with) the application.

Aggregating node-local resources to provide the intermediate storage offers a number of advantages: higher performance - as applications benefit from a wider I/O channel obtained by striping data across several nodes; higher efficiency – as it improves resource utilization; incremental scalability – as it is possible to increase system capacity in small increments. This scenario also opens the opportunity for optimizing the intermediate storage system for the target workflow application: a storage system used by a single workflow, and co-deployed on the application nodes, can be configured specifically for the I/O patterns generated by the workflow (e.g., configure striping and replication to eliminate hot spots, use a data placement policy to maximize data access locality) [8].

These benefits, however, come at a price: configuring the intermediate storage system becomes increasingly complex for multiple reasons. First, the optimization techniques commonly used in distributed environments expose trade-offs that rarely exist in centralized solutions [9, 10]. Second, each application may obtain peak performance at a different configuration point - not linear with the amount of resources of values for configuration parameters, a consequence of different I/O patterns [11, 12, 10, 9]. Third, depending on the context, there are multiple metrics of interest to optimize: e.g., response time, throughput, energy, and, increasingly common in cloud computing environments, the cost of resources.

Further complicating this scenario, the user faces resource allocation decisions that often entail trade-offs between cost and application turn-around time [12, ?, ?]. Typical allocation choices involve deciding the number of nodes for the application in batch-computing environments (e.g., clusters) and specifying the nodes’ ‘type’ in cloud-computing environments (i.e., per-node configuration in terms of compute, memory, storage and network capabilities).

To illustrate these points, consider the following optimization techniques and their trade-offs. Data striping may accelerate data access, yet it decreases reliability and requires more resources. Increasing the number of storage nodes can avoid data access bottlenecks, yet it may expose metadata management scalability bottlenecks. Higher redundancy levels (through replication or erasure codes) may accelerate data access and increase reliability, yet they also require more resources and complex consistency protocols. Finally, different data placement and/or caching policies are beneficial to different workloads.

Past work and our own experience support these assertions. They show that different applications achieve their best performance when using different storage configurations [6, 11]. Also, different applications even benefit from different combinations of storage optimization techniques [8, 13], and that the choice of the optimal configuration point is not intuitive (Figure 1).

In this scenario, the role of the application administrator/user becomes non-trivial: in addition to being in charge with running the workflow application, the user has to choose how to partition the allocation between nodes to execute the application and nodes to run the intermediate storage system. Additionally, for each provisioning configuration (i.e., number of allocated nodes running the storage system), there is a wide spectrum of storage system configurations (e.g., replication level, chunk size, cache and data placement policies, or stripe width) that deliver different storage system performance [11, 8]. Consequently, provisioning the system entails searching a complex multi-dimensional configuration space to determine the user’s ideal cost/performance balance point. Providing support for this activity is the focus of our project [14].

Figure 1: Different storage system configurations deliver different performance and the choice of the optimal configuration point is not intuitive. To demonstrate that this holds for workflow applications, we have executed the Montage workflow [2] on top of MosaStore [6] storage system with different storage configurations deployed over the Grid’5000 platform. We executed the same workload for several values of one configuration knob: stripe width. As we increase stripe width, we also increase the number of storage nodes to support it. For a low stripe width, performance is low due to congestion at the storage nodes and, for higher values, performance decreases due to connection handling and metadata access overheads. A user seeking the optimal point would pick a stripe width value close to five, a non-obvious choice. Other case studies can be found in [8].

This work proposes an approach for exploring this space and helping the user select an allocation, a partitioning, and an intermediate storage system configuration that meets well the user’s desired cost/performance balance point.

The contributions of this paper lay over multiple axes:

  • Highlights the system provisioning, allocation and configuration problem, presenting it as a multi-objective optimization problem, and presents an approach for exploring this complex decision space.

  • Synthesizes the key requirements for a prediction mechanism that will be useful in practice (§2.1).

  • Proposes a simple queue-based model for distributed, object-based storage systems (§2.3). This model, at the base of the prediction mechanism, is: generic (i.e., covers the traditional design for object-based datastores), and homogeneous (all nodes are based on the same model).

  • Proposes a system identification procedure to seed the model that is simple, lightweight, effective, and does not require system changes to collect monitoring information (§2.5).

  • Presents experience with using this prediction mechanism when evaluated independently with synthetic benchmarks (§3) and in the context of making configuration choices for two different scenarios with a real application. These scenarios give a glimpse of how the application execution time can vary depending on the choices made and indicates that the predictor will be able to guide the search for the desired balance cost/time-to-solution. Our experience shows that the predictor is lightweight (200x to 2000x less resource intensive than running the application itself) and accurate (80

  • Finally, this paper discusses our experience (§5) to date with using the prediction mechanism beyond our original design goal: we have used the performance prediction to better understand and debug a distributed storage system that our group develops.

The Problem. Configuring the intermediate-storage system to achieve high performance (e.g., in terms of application turnaround time, storage footprint, energy consumption, or financial cost), involves choosing a set of storage system configuration parameters (such as stripe width, data placement policy, and replication level).

Additionally, for many-task applications, the user is concerned about resource allocation. Thus, the decision space we investigate revolves around three axes: provisioning - total number of nodes, deciding on node type(s) (or node specification); partitioning – splitting these nodes between the application and the intermediate storage system; and configuration choice – for each subsystem choosing an optimal configuration, in this case choosing replication level, stripe width, chunk size, cache/prefetching and data placement policies for the intermediate storage system.

In this complex space, generally the user’s goal is to optimize a multi-objective problem, in at least two dimensions: maximize performance (e.g., reduce application execution time) while minimizing cost (e.g., reduce the total CPU hours or dollar amount spent). More concretely the user is often interested in answering specific questions: How should the configuration of the storage system be? What is the allocation that can achieve the lowest total cost? How should I partition the allocation among application and storage nodes to achieve the highest performance? What is the allocation that is most cost efficient (i.e., has lowest cost per unit of performance)?

Manually fine-tuning the storage system configuration parameters and allocation descisions is undesirable for multiple reasons. First, the user lacks a deep understanding of how different configuration choices affect the system’s performance. Second, the workload may vary: new application versions may make one-time tuning obsolete. Finally, performance tuning is time-consuming due to the large configuration space to consider.

This works presents our progress to date on designing and evaluating a performance prediction mechanism for object-based storage systems in the context of workflow applications. Given a storage system configuration, an application I/O profile, and a characterization of the deployment platform based on a simple system identification process (e.g., storage nodes service time, network characteristics), the mechanism predicts the total application turnaround.

This approach can support four important tasks: First, autotuning, a software tool that relies on the proposed mechanism can enable efficiently configuring the storage system [14, 9, 10], through exploring the configuration space without actually running the application. Second, resource provisioning, it can inform the decision of (i) the number of nodes to be allocated, (ii) how to partition allocated nodes between application and storage nodes to achieve a certain performance level. Third, new technology evaluation, it can estimate the application performance on hardware that has not yet been procured (e.g., to help answer the question: what would be the performance improvement if we used SSDs?). Finally, the mechanism can help explore the impact of configuration choices in situations where direct measurement is difficult or requires specialized infrastructure (e.g., energy consumption).

This paper focuses on predicting the application turnaround time, but we note that the model and approach presented apply readily to other optimization metrics.

2 The Design of a Performance Estimation Mechanism

This section discusses the requirements for a practical performance prediction mechanism (§2.1) and presents the key aspects of the object-based storage system architecture modeled (§2.2). Then, it focuses on the proposed solution: it presents the model (§2.3), its implementation (§2.4), the system identification process to seed the model (§2.5), and an overview of the workload description (§2.6).

Making accurate performance predictions for distributed systems is a challenge. Since in most cases purely analytical models can not provide adequate accuracy, simulation is the commonly adopted solution. At the one end of the design spectrum, current practice (e.g., NS2 simulator [15]) suggests that while simulating a system at low granularity (e.g., packet level simulation in NS2) can provide high accuracy, the complexity of the model and the number of events generated make accurately simulating large-scale systems infeasible. At the other end, coarse grained simulations (e.g., [16, 17]) scale at the cost of lower accuracy

Two key observations to reduce simulation complexity and increase its scalability: First, as the goal of the simulation is to support configuration choice for a specific workload, achieving perfect accuracy is less critical (§3). Second, we take advantage of the fact that we know the workload characteristics generated by workflow applications: relatively large files, single-write-many-reads, and specific data access patterns. These observations enable us to reduce the simulation complexity by not simulating in detail some of the control paths that do not significantly impact accuracy (e.g., the chunk transfer time is dominated by the time to send the data, consequently not accounting the time of the acknowledgment messages or the metadata message transfer will not tangibly impact accuracy).

2.1 Solution Requirements

A practical performance prediction mechanism should meet the following, partially conflicting, requirements that bound the solution space:

  • Accuracy. The mechanism should provide adequate accuracy. Of course better accuracy is desirable; however, in the face of practical limitations to achieve perfect accuracy, we note that there are decreasing incremental gains for improved accuracy in practical settings. For example, to support decisions about configuration choices a predictor only needs to correctly estimate their relative performance or trends of changing a configuration parameter. Even more, if two configurations offer near performance, their relative predicted performance is less important as long as the prediction mechanism places their performance as similar.

  • Scalability and Response Time. The predictor should enable the quick exploration of the configuration space. To this end, the mechanism should offer performance predictions quickly and scale across at least two dimensions: (i) it should scale with the system size and be able to model large systems; and (ii) it should scale with the I/O intensity and be able to model I/O intensive applications.

  • Usability and Generality. The predictor should not impose a burdensome effort to be used. Specifically, the bootstrapping/seeding process should be simple and it should not require storage system redesign (or a particular initial design) to collect performance measurements. Additionally, ideally the prediction mechanism should model a generic object-based distributed storage design and using it should not require in-depth knowledge of storage system protocols and architecture.

  • Ability to explore “what-if” scenarios. A prediction mechanism should be able to support exploring hypothetical scenarios, such as scenarios that assume new/different hardware configurations (e.g., usage of SSDs). We note that there are two main categories for the models at the foundation of all performance prediction mechanisms: explanatory and agnostic models. The explanatory models try to mimic the key components of the system and their interaction at various levels of accuracy and granularity. The agnostic model aims to predict the output metric of interest being completely oblivious of system internals (e.g., a neural network based models would fit in this category). Supporting “what-if” scenarios exploration requires an approach based on an explanatory model.

2.2 Object-based Storage System Design

We focus on a widely-adopted object-based storage system architecture (such as that adopted by GoogleFS ‎[18], PVFS [19], MosaStore [6], and UrsaMinor [11]). This architecture includes three main components: a centralized metadata manager, storage nodes, and a client-side system access interface (SAI). The manager maintains the stored files’ metadata and system state. To speed up data storage and retrieval, the architecture employs striping ‎[20]: files are split into chunks stored across several storage nodes. Client SAIs implement data access protocols after they interact with the manager that stores data placement information.

Data placement. The default data placement generally adopted is round-robin: when a new file is created on a stripe of n nodes the file’s chunks are placed in a round-robin fashion across these nodes. Additionally, data placement policies that optimize for a specific application access patterns have seen higher adoption [8, 21, 22]. For instance, the following data placement policies are used to optimize for the workflow applications’ data access patterns: local, co-locate and broadcast (detailed in §3).

Replication. Replication is often used to increase reliability or to improve access performance. Data is replicated when new data is stored in the system, consequently, while a higher replication level will reduce contention on the node storing a popular file, it will increase the file write time and the storage space consumption.

We explore the accuracy of the prediction mechanism assuming that the stripe width, replication level, and data placement policy are configurable as suggested in [8, 11, 6]. Our approach can be extended to support other configuration parameters.

2.3 System Model

Our solution uses a queue-based storage system model for the system components’ operations and their interactions. The model requires three inputs from the user: the storage system configuration, a workload description, and the performance characteristics of storage system components (i.e., system identification). The simulator instantiates the storage system model with the specific component characteristics and configuration, and simulates the application run as described by the workload description.

All participating machines are modeled similarly, regardless of their specific role (Figure 2): each machine hosts a network component and can host one or more system components (each modeled as a service with its own queue).

A system component and its queue represent a specific functionality: that is, the manager component is responsible for storing files’ and storage nodes’ metadata. The storage component is responsible for storing and replicating data chunks. Finally, the client component receives the read and write operations from the application, implements, at the high-level the storage system protocol by sending control or data requests to other services, and once a storage operation is terminated it communicates again with the application. Each of these components is modeled as service that takes requests from its queue (fed by the network service or by the application for the client service) and sends responses back through the network service (or directly to the application, again for the client).

The network component and its in- and out- queues model the network-related activity of a host. Key here is to model network-related contention while avoiding modeling the details of the transport protocol (e.g., dealing with packet loss, connection establishment and teardown details). The requests in the out-queue of a network component are broken in smaller pieces that represent network frames and sent to the in-queue of the destination host. Once the network service processes all the frames of a given request in the in-queue, it assembles the request and places it in the queue of the destination service.

Figure 2: Queue-based model of a distributed storage system. Each component (manager, client component, and storage component) has a single system service that processes requests from its queue. Additionally, each host has a network component with an in- and out- queue. The network core connects and routes the messages between the different components in the system and can model network latency and contention at the aggregate network fabric level. Solid lines show the flow going out from a storage system component while dashed lines show the in-flow path.

The system components can be collocated on the same host (e.g., the client and storage components running on the same host). In this situation, requests between collocated services also go through the network, but have a faster service time than remote requests - representing a loopback data transfer (§2.5).

Space limitations prevent us from presenting the full details of the model. As a rule, we accurately model the data paths at chunk-level granularity, and the control paths at a coarser granularity: modeling only one control message to initiate a specific storage function while an implementation may have multiple rounds of control message exchanges. We used our own experience with designing and implementing an object-based storage system [23].

2.4 Model Implementation

We have implemented the above model as a discrete-event simulator in Java. The simulator receives as inputs: a summarized description of the application workload (described in §2.6) and a description of the deployed system which has two parts. The first part describes the system-wide configuration parameters (currently, replication level, stripe-width, chunk size, and data-placement system-wide) and the details of the system: number of hosts, number of storage nodes and clients, whether storage and clients nodes are collocated on the same hosts. The second part characterizes the performance of system components: service times for network, client, storage, and manager (the process of identifying these values is described in §2.5).

Once the simulator instantiates the storage system, it starts the application driver that processes the application workload. The driver reads the description of the application workload, creates the corresponding events (e.g., read from file at offset , bytes) and places them in the client service queue. File-specific configuration (as proposed by [11, 8]) is described as part of the application workload description since it depends on the file that application reads/writes.

As in a real system, the manager component maintains the metadata of the system (i.e., implements data placement policies by returning free chunks when requested by write operations, and keeps track of file to chunk mapping and chunk placement). To make the process clearer, consider the following example for a write operation where a client module processes a file write event. First, the client contacts the manager asking for free space. The manager replies specifying a set of free chunks and their storage services to be used during this write. Then, the client requests each storage service to store chunks in a round-robin fashion. After processing a request to store a chunk, a storage service replies to the client acknowledging the operation success. After sending all the chunks, the client sends to the manager the chunk-map (where each chunk is stored). Then, once the manager acknowledges, the client returns success to the application driver. In total the write operation generates two requests to the manager and one request per chunk to the storage nodes.

Note that the specific set of storage components returned by the manager in the beginning of a write operation depends on the data placement policy used. A typical set is composed of stripe-width of storage services, but it can be composed of just one, e.g., when a local data placement is desired.

To model per-file optimizations, the client can overwrite system-wide configurations by requesting the manager to provide support for a specific data placement scheme. For example, the client may require that a file is stored locally, that is, on a storage service that is located on the same host. In this case, the manager attempts to allocate space on that specific storage service for that write operation (as opposed to striping the data across multiple storage services). The file-specific data placement policy is part of the workload description.

All communication among the system services uses the network. Each network request has its destination address, which is used by the simulator to determine which network queue should receive a packet.

Currently, the simulator reports the time spent, data transferred and storage used per each read or write. Additionally, one may request to collect aggregated information for specific points of the simulation.

2.5 System Identification

To instantiate the storage system model, one needs specify the number of storage and client components in the system, and define the service times for the network () and the system components (storage - , manager - , and client - ).

The system identification process is automated with a script as follows. First, to measure the service time per chunk/request ), a script runs a network throughput measurement utility tool (e.g., iperf [24], ), to measure the throughput of both: remote and local (loopback) data transfers. Second, this script measures the time to read/write a number of files to identify client and storage service time per data chunk. To this end, the system identification script deploys one client, one storage node and the manager on different machines, and writes/reads a number of files. For each file read/write the benchmark records the total operation time. At the end of its execution, the script computes the average read/write time . The number of files read/wrote is set to achieve 95% confidence intervals with accuracy according to the procedure described in [25].

The operation total time () includes the client side processing time (), the storage node processing time (), the total time related to the manager operations () , and the network transfer time (). The network service time for the network () is based on a simple analytical model based on network throughput and proportional to the amount of data to be transferred in a packet.

To isolate just , the script runs a set of reads and writes of 0-size. This forces a request to go through the manager, but it does not touch the storage module. Since decomposing and is not possible without probes in the storage system code, we opted to associate the and associate the whole cost of 0-size operations to the manager. While iperf can estimate , and the script can infer , and therefore . To obtain the service time per chunk, the times are normalized by chunk size. Therefore, .

2.6 Workload Description

The simulator takes as an input a description of the workload to be simulated. The workload description contains two pieces of information: per client I/O operations trace (i.e., open, read, write, close calls with the call details: timestamp, operation type, size, offset, and client id), and a files’ dependency graph (capturing the operation dependency). The client traces can be obtained by running and profiling the application. The storage system logs often already provide these traces. Generating the file dependency graph can either be provided by the workflow scheduler (e.g., Swift [4]), by an expert user or automatically extracted from log files. Automating the extraction of the file dependency graph and client traces from storage system logs is an ongoing effort at our research group and is out of the scope of this paper.

3 Evaluation

This section aims to evaluate the mechanism’s prediction accuracy and, more importantly, to demonstrate through a set of experiments the mechanism’s ability to support correctly identifying quise-optimal configuration for a specific application. To this end, we use a set of synthetic benchmarks and a real application.

The synthetic benchmarks are designed to mimic real workflow application access patterns [8] of workflow applications. The goal is to evaluate the mechanism’s ability to predict time consumed under more complex system interactions that resemble the application ecosystem, we target and the storage system optimizations used in this context.

Finally, to understand how use the prediction mechanisms can be in a real set-up, we use BLAST [3] as an example of a real scientific application. The goal is to evaluate how the ability to predict time-to-solution can support user’s decisions when the user has to decide about the storage configuration and allocation.

Storage system. The storage system used is MosaStore. The storage nodes are backed up by RAMDisk. We choose to experiment with RAMDisks as they are frequently used to support workflow applications: it offers higher performance and are the only option in some supercomputers that do not have spinning disks (e.g., IBM BG/P machines). We briefly discuss a disk based evaluation in §5.

Deployment platform. We use a testbed of 20 machines each with an Intel Xeon E5345 4-core, 2.33-GHz CPU, 4GB RAM, and 1-Gbps NIC. One machine runs the MosaStore manager while the other 19 machines each run both a storage node and a client access module.

System identification. The simulator is seeded according to the procedure described in §2.5.

3.1 Synthetic Benchmarks for Workflow Patterns

This section evaluates the accuracy of the prediction mechanism capture the behavior of the system with multiple clients, the interaction among multiple applications, or the impact of data-placement policies designed to support workflow applications [8, ?]. We use synthetic benchmarks that mimic common data access patterns existent in workflow applications. Specifically, this section focuses on pipeline, reduce, and broadcast patterns (Figure 3). These are among the most used patterns uncovered by studying over 20 scientific workflow applications by Wozniak et al. [7], Shibata et al. [26], and Bharathi et al. [27]).

Additionally, these synthetic benchmarks are designed to explore the limitations of the predictor and be a worst case in terms of accuracy as they are composed exclusively of I/O operations, which leads to contention in the real storage system that are well-known for being difficult to model accurately LABEL:REF.

Experimental setup. We use the MosaStore setup described above. We use the DSS label (from generic Distributed Storage System) for experiments where we use MosaStore default configuration: client and storage modules run on all machines, client stripes data over all 19 machines, and there is no data-access pattern optimization enabled. We use the WASS label (Workflow Aware Storage System) when the system configuration is optimized for a specific access pattern (including data placement, stripe width or replication) [8]. All WASS experiments assume data location aware scheduling: for a given compute task, if all input file chunks exist on a single storage node, the task is scheduled on that node to increase access locality. The storage nodes are backed up by RAMDisk as they are frequently used to support workflow applications: they offer higher performance, is key part of the a intermediate storage system to speed-up workflow application, and are the only option in some HPC centers that do not have spinning disks (e.g., IBM BG/P machines).

The goal of showing results for two different configurations choices is two-fold: (i) demonstrate the accuracy of the predictions for two different scenarios, and (ii), most important, show that the predictions correctly indicates which configuration is the best. To understand the impact of the data size, for each benchmark, we use (where possible) two workloads labeled as the medium and, a 10x larger, large workload. We omit results for a small workload, which is 10x smaller than medium, because it already exhibits a similar performance between different configurations [8].

For actual performance, the figures show the average turnaround time and standard deviation for 15 trials. It is enough to guarantee a 95

Figure 3: Pipeline, Reduce, and Broadcast benchmarks. Nodes represent workflow stages and arrows represent data transfers through files. The file sizes represent the medium workload. Files in the large workload are 10x larger.

Pipeline benchmark. A set of compute tasks are chained in a sequence such that the output of one task is the input of the next task in the chain (Figure 3). A pipeline-optimized storage system will store the intermediate pipeline files on the storage node co-located with the application. Later, the workflow scheduler places the task that consumes the file on the same node, increasing data access locality. Here, 19 application pipelines run in parallel and go through three processing stages that read input from the intermediate storage and write the output to the intermediate storage. (We present only results for the medium workload as the large workload does not fit in the RAMdisk of the machines of our testbed).

Evaluation results. Figure 4 shows the evaluation results. The simulator produces estimates equivalent to actual results for the optimized configuration (WASS). For no optimization (DSS), the prediction is 16% smaller (standard deviation considered). Note that for a case with default data placement policy, all clients stripe (write) data to all machines in the system; similarly, all machines read from all others. This creates, a complex interaction among all components in the system and some retries due to connection timeouts caused by network congestion which, we believe, is the source of the prediction inaccuracy.

Figure 4: Actual and predicted performance for the pipeline benchmark and medium workload. Error bars show the standard deviation.

Reduce or Gather benchmark. A single compute task uses input files produced by multiple tasks. Real-world situations that generate this pattern include a task that checks the results of other tasks executed in parallel for a convergence criterion, or a task that calculates summary statistics from the output of many tasks. A possible data placement optimization is the use of collocation i.e., placing all these input files on one node and expose their location, which will later be used by the scheduler to run the reduce task on that machine. In the benchmark, 19 processes run in parallel on different nodes, consume an input file, and produce an intermediate file. In the next stage of the workflow, a single process reads all intermediate files and produces the reduce-file. Data sizes are indicated in Figure 3. In this scenario, for WASS configuration, the collocation optimization is enabled for the files used in the reduce stage, for the remaining files the locality optimization is enabled.

Evaluation results. Similar to the pipeline benchmark, predictions for the reduce benchmark are within 20% of the actual performance (Figure 5) and, more importantly, they capture the relative improvements that pattern-specific data placement policies policy can bring. We note that Figure 5(b) captures the behavior of a heterogeneous scenario: We used a faster machine with a larger RAMDisk to run the reduce stage since the RAMDisk of the typical machine in the testbed is too small. Despite heterogeneity, the predictor captures the system performance with accuracy similar to a homogeneous system.

When the collocation and locality optimizations are not enabled, the challenge of capturing exactly the system behavior is similar to the pipeline case: capture the complex interactions among all machines in the system. When the specific data placement is enabled though, the challenge is different: there is a high contention created by having several clients writing to the same storage machine (the one that performs the reduce phase). Figure 5(c) shows the results per-stage for the two stages of the large workload.

(a) Medium (b) Large (c) Large per Stage for WASS

Figure 5: Actual and predicted performance for the reduce benchmark for the medium, large workloads, and per stage for large workload. Error bars show the standard deviation.

Broadcast benchmark. A single task produces a file that is consumed by multiple tasks. In this benchmark, 19 processes running in parallel on different machines consume a file that is created in earlier stage by one task. A possible optimization for this pattern is to create replicas of the file that will be consumed by several different tasks. Data sizes are indicated in Figure 3.

Evaluation results. Figure 6 shows the results for broadcast pattern with medium workload with the WASS system configured with 1, 2, or 4 replicas (the large workload shows a similar trend and we omit it here). For this benchmark all predictions matched the actual results: predictions were inside the interval of mean of actual standard deviation, just 1-2% difference from the mean. This experiment highlights an interesting case for the predictor. According to the structure of the pattern and the results reported in [8] (admittedly on a slightly different setup), creating replicas would improve the performance of the broadcast pattern. The results, however, show that creating replicas does not really help here. This happens because striping to many machines already avoids the contention of a single node holding the file. So, although creating replicas can alleviate the number of accesses to a given machine (since chunks are read in sequence), this gain is not paid off by the overhead of creating a replica. More importantly in our context, this is another situation where the predictor captures the impact of different configurations, showing, in this case that they are equivalent and the user can stick with one replica and save storage space.

Figure 6: Actual and predicted performance for broadcast benchmark and medium workload. The experiment uses the WASS system while varying the replication level. Error bars show the standard deviation.

Synthetic Benchmarks: Summary. The evaluation so far demonstrates good accuracy: our approach leads to errors of 6% on average, lower than 9% in 90% of the studied scenarios, and within 20% in the worst case. More importantly, the mechanism correctly differentiates between the different configurations and could support choosing the best configuration for each scenario in our evaluation.

3.2 Supporting decisions for a real application

Section 3.1 presents the evaluation for the predictor’s ability to accurately predict the turnaround time of synthetic benchmarks that are impacted by different optimizations enabled in the storage system. This section targets a more complex scenario where the user has to deal with a real application, allocation decisions, and the storage system configuration. To this end, the evaluation shows the predictor’s ability to correctly guide the user or a search algorithm to the desired configuration, specifically focusing on two provisioning scenarios:

  • Scenario I assumes that the user has full access to a fixed-size cluster, a common set-up in several university research labs. The question we answer is how should the system be partitioned between application and storage nodes and what will be the intermediate storage system configuration for best application performance?

  • Scenario II explores the provisioning problem with cost constraints (e.g., in HPC centers with limited user budget or cloud environments). The question to answer is: for a fixed application workload; what is the cost/turnaround time trade-off space among the deployment options?

Workload. We explore these two scenarios with a real workflow application: BLAST [3] a DNA search tool for finding similarities between DNA sequences. Figure 4 shows the BLAST workflow. Each node receives a set of DNA sequences as input (a file for each node) and all nodes search the same database file. The workload includes 200 search queries using the RefSeq database (total size of 1.67 GB). The input files and the intermediary files are stored in the intermediate storage system.

Figure 7: The BLAST database (1.67GB) is used by all nodes that search in parallel different queries. We assume the database is already loaded in intermediate storage.

Testbed. Among the 20 machines of the testbed; one node coordinates BLAST tasks’ execution and runs the storage system manager. The remaining nodes can either execute tasks from the workload or act as storage nodes.

Experimental methodology. The plots in this paper section reports the average of at least 20 runs. We have obtained 95

Scenario I: Configuring a fixed size cluster.

This scenario addresses the following question: Given a fixed size cluster, how should the nodes be partitioned between the application and the intermediate storage, and what should be the intermediate storage system configuration to yield highest application performance?

Figure 8 shows the application execution time with different partitioning and storage system configurations. As a proof of concept and to limit the number of possible configurations, we experiment with varying only one system configuration knob: chunk size. We chose chunk size because it has the highest impact on the BLAST workflow, and to present results for a know not covered with synthetic benchmarks.

Figure 8 shows: First, the difference between the different configurations is significant (up to 10x difference between the best and the worst configuration given the same chunk size. Second, the results show that the system achieves the fastest processing time with a partitioning of 14 application nodes and 5 storage nodes, and chunk size of 256KB (4x smaller than the default size) a non-obvious configuration beforehand. Finally, the experiment shows that the predictor accurately captures the system performance given changes in the allocated partition, and on the storage system configuration. Therefore, it shows that the predictor can correctly lead the search algorithm to the desired configuration.

Figure 8: Application runtime (log-scale) for a fixed-size cluster of 20 nodes. X-axis represents number of nodes allocated for the application/storage. The three plots represent runtime for different storage configurations (chunk sizes).
Figure 9: Allocation cost (total CPU time on the left Y axis) and application time (right Y axis) for fixed size clusters of 11, 17, and 20 nodes while varying the chunk size. X-axis represents number of nodes allocated to the application/storage. The figures show the actual (lines) and the predicted (arrows) cost/performance. Note: Log scale on Y-axis.

Scenario II: Provisioning in an elastic and metered environment.

This scenario assumes an environment where users are charged (as the cumulative CPU-hours used) and where they have a more complex tradeoff between cost and time-to-solution to make. We aim to inform the user’s provisioning decisions by revealing the details of this trade-off. Specifically, this scenario helps the user to answer the following question: What is the allocation size, and how should it be portioned and configured to best fit my requirements?

Figure 9 shows the application execution time and allocation cost measured in total allocation time (number of nodes x allocation time) with different cluster sizes, different partitioning, and different chunk size. The figure shows that an allocation of 11 nodes, with partitioning of 8 application, 2 storage nodes, and chunk size of 256KB offers the lowest cost. However, the user can analyze Figure 9 to verify that an option with an allocation of 20 nodes actually offers almost 2x higher performance at a similar cost (less than 2

3.3 Time to search the space

. Finally, an important point to evaluate is time to predict the performance of a given scenario. In our preliminary implementation, predicting simulations take roughly 10x to 100x less time than actual execution and uses only one machine. Since the application uses up to 20 nodes for actual runs, this means the simulator consumes approximately 200x to 2000x fewer resources than actual executions, enabling a deeper exploration of the search space.

4 Related Work

This section describes briefly past work on storage system performance prediction and how it differs from our work.

Past work used model-driven analysis to estimate performance of storage systems. For instance, Ergastulum [28] targets centralized storage solution based on one enclosure to recommend an initial configuration of the system, and Hippodrome [29] relies on Ergastulum to improve the configuration based on online monitoring of the workload. By considering a distributed system, our solution handles more complex interaction among the system components and more configuration options.

Similar to this work, Thereska et al. [9] proposed an predictor mechanism for a distributed storage system with a detailed model. To provide such information, they propose Stardust [30] a detailed monitoring information system that required changes to the storage system and kernel modules to add monitoring points. This approach enabled their predictor to achieve prediction within 18% of the actual predictions depending on the workload. Our approach have achieved similar accuracy on our target workload, however with a lightweight approach to seed the model.

An important difference to past work on storage systems performance is our focus on a whole workflow application and the potential interaction among the workflow’s phases instead of the average performance for a batch (e.g., [28, 29]) of operations, and of predicting performance of the system from the perspective of just one client [9]. Additionally, our work targets the partitioning problem of splitting the nodes among application and intermediate storage.

Recently, Elastisizer [?] targeted a similar problem automating allocation choices for an entire application. This work, however, does not address the aspects of workflow applications or storage system configuration since it focuses on a different class of application: Map Reduce jobs.

Recently, Z. Zhang et al. has proposed an approach to determine the storage bottleneck for a given many-tasks application (a class of workflow) based on a set of benchmarks and executions of the the application. The approach we propose enable a richer exploration of the system by a lower cost since the predictor is able to estimate performance of a scenario that add or reduce resources and change the configuration without requiring new runs of the application of the benchmarks.

5 Summary and Discussion

This paper makes the case for a prediction mechanism to support automating provisioning choices for workflow applications. We focus on predicting the performance of workflow applications when running on top of an intermediate object-based storage system. We propose a solution based on a queue-based model with a number of attractive properties: a generic and uniform system model; supported by a simple system identification process that does not require specialized probes or system changes to perform the initial benchmarking; with a low runtime to obtain predictions; and, finally, with adequate accuracy for the cases we study.

We intend to expand this work in multiple directions: (i) explore a richer space of configuration parameters, (ii) evaluate the system using additional benchmarks and applications, (iii) enable different optimization functions [10, ?], and including adding energy models [13], and (iv) explore different optimization solvers to search the configuration space.

The discussion below aims to clarify our understanding of the limitations of our work and the lessons we have learned during this exercise so far.

What are the main sources of inaccuracies? Currently, there are sources of inaccuracies at multiple levels: First, the model does not capture all the details of the storage system (e.g., support services like garbage collection or storage node heartbeats; the control paths are simplified to match what we believe generic object-based storage would do - while we know that a FUSE-based implementation would need more complex control paths; we model all control messages as having the same size) and the environment (e.g., contention at the network fabric level or scheduling). Second, we constrain and simplify system identification even further at the cost of additional accuracy loss. Third, we do not model the infrastructure in detail (e.g., we do not model the network protocols or the spinning disks). Finally, so far the application driver uses an idealized image of the workflow application (e.g., all pipelines are launched in the simulation exactly at the same time while in the experiments on real hardware coordination overheads make them slightly staggered). We believe the latter one is the main reason of current inaccuracies in the system and should be address by a richer workload description.

What is the accuracy when the intermediate storage is deployed on spinning disks? So far, we have focused on predicting performance when intermediate storage is deployed over RAMDisks for two reasons: This is a common setup on large systems (as some, do not even have spinning disks) and the individual performance of RAMdisks is simpler to predict (the service time for spinning disks is history dependent due to cache behavior and position of disk head). The storage service we use does not model history-dependent behavior, thus we expect lower accuracy predictions when the system is deployed over spinning disks. (This can be fixed, by using a more sophisticated model of the storage service and it is part of our future work).

We have evaluated, however, how the current (unchanged) model performs when using spinning disks for the simple synthetic benchmarks used in the evaluation section. Figure 10 shows the results for the reduce pattern when using the medium and large workloads. The key observation here is that, although prediction accuracy is lower, predictions are good enough to make the correct choice between DSS and WASS, that is, the choice on whether to use the data co-placement optimization for each of the workloads (note that this optimization is beneficial in one case and it detrimental in the other one). Pipeline benchmark on HDDs shows similar results to RAMdisks (Figure 4).

Figure 10: Actual and predicted performance for the reduce benchmark on HDD - medium(left) and large (right) workload. The results for WASS is this experiment are not directly comparable to the corresponding ones for spinning disks as we use a slower node for data co-placement, keeping the system homogeneous.

Can the performance prediction mechanism support the development process of a storage system? Do you have specific experience with using the mechanism in this context? One of the lessons we have learned so far is the utility of the mechanism to support development of the storage system itself. Back of the envelope calculations are a common mechanism to evaluate expected performance bounds for a given system. The predictor takes this a step further and is useful in complex scenarios where back of the envelope estimates were intractable. Not only developers can use it to evaluate the potential gains of implementing a new complex optimizations or to study the impact of faster network and nodes, but also the mechanism can be used as a baseline to detect performance anomalies.

More concretely, we have encountered a number of situations where the predicted and actual performance differed significantly. In some cases these highlighted simplifications in the model or in our simulator. But, more importantly, there were cases that highlighted complex performance-related anomalies that were fixed in the storage system such as: non-trivial implementation problems (e.g., limited randomness in the data placement decisions that created an artificial bottleneck, or unreasonable locking overheads at the manager). Similarly, the prediction mechanism helped us revisit assumptions about the middleware stack the storage system is implemented over (e.g., we have discovered the significant impact of the TCP connection initiation timeout of 3s in some scenarios); and highlighted shortcomings of the seeding process or incorrect assumptions about the deployment platform (e.g., we were ignoring platform heterogeneity).

How to decide when to stop increasing the level of detail in the model and the complexity of system identification? We aim to model only the key interactions between system components. Modeling all system subcomponents and all their interactions in detail would be too complex. Such complexity could improve prediction accuracy, but would have significant drawbacks: significantly more complex model (as complex as the actual storage system and the underlying environment (e.g., network protocols, operating system buffers, scheduling), complex seeding process, lower scalability, and loss of the model generality. Further, the improvement in accuracy may not add much value (e.g., when the prediction mechanism is used to decide between system configurations). We followed a top-down approach: we started from a simple model and added more components or interactions’ details until the accuracy of the all predictions was within 10% of actual performance (and the median error was within 5%) for the set of microbenchmarks.

Acknowledgements

We would like to thank Emalayan for his collaboration in MosaStore development; Elizeu Santos-Neto and Abdullah Gharaibeh for their collaboration in keeping the quality of the code via code reviews.

References

  1. Moont, G.: 3d-dock suite. http://www.sbg.bio.ic.ac.uk/docking/ (2012)
  2. Berriman, G.B., Good, J.C., Curkendall, D., Jacob, J., Katz, D.S., Prince, T.A., Williams, R.: Montage: An on-demand image mosaic service for the nvo. Astronomical Data Analysis Software and Systems XII ASP Conference Series 295 (2003) 343
  3. Altschul, S.F., Gish, W., Miller, W., Myers, E.W., Lipman, D.J.: Basic local alignment search tool. Journal of molecular biology 215(3) (October 1990) 403–410
  4. Wilde, M., Hategan, M., Wozniak, J.M., Clifford, B., Katz, D.S., Foster, I.T.: Swift: A language for distributed parallel scripting. Parallel Computing 37(9) (2011) 633–652
  5. Deelman, E., Singh, G., hui Su, M., Blythe, J., Gil, Y., Kesselman, C., Mehta, G., Vahi, K., Berriman, G.B., Good, J., Laity, A., Jacob, J.C., Katz, D.S.: Pegasus: a framework for mapping complex scientific workflows onto distributed systems. Scientific Programming Journal 13 (2005) 219–237
  6. Al-Kiswany, S., Gharaibeh, A., Ripeanu, M.: The Case for Versatile Storage System. In: Workshop on Hot Topics in Storage and File Systems (HotStorage). (2009)
  7. Wozniak, J.M., Wilde, M.: Case studies in storage access by loosely coupled petascale applications. In: Proceedings of the 4th Annual Workshop on Petascale Data Storage, New York, NY, USA, ACM (2009) 16–20
  8. Vairavanathan, E., Al-Kiswany, S., Costa, L.B., Zhang, Z., Katz, D.S., Wilde, M., Ripeanu, M.: A workflow-aware storage system: An opportunity study. In: Cluster Computing and the Grid, IEEE International Symposium on. (2012) 326–334
  9. Thereska, E., Abd-El-Malek, M., Wylie, J.J., Narayanan, D., Ganger, G.R.: Informed data distribution selection in a self-predicting storage system. In: Proceedings of the 3rd International Conference on Autonomic Computing. (2006) 187–198
  10. Strunk, J.D., Thereska, E., Faloutsos, C., Ganger, G.R.: Using utility to provision storage systems. In: 6th USENIX Conference on File and Storage Technologies, FAST. (2008) 313–328
  11. Abd-El-Malek, M., II, W.V.C., Cranor, C., Ganger, G.R., Hendricks, J., Klosterman, A.J., Mesnier, M.P., Prasad, M., Salmon, B., Sambasivan, R.R., Sinnamohideen, S., Strunk, J.D., Thereska, E., Wachs, M., Wylie, J.J.: Ursa minor: Versatile cluster-based storage. In: Proceedings of the Conference on File and Storage Technologies. (December 2005)
  12. Cirne, W., Berman, F.: Using moldability to improve the performance of supercomputer jobs. J. Parallel Distrib. Comput. 62(10) (2002) 1571–1601
  13. Costa, L.B., Al-Kiswany, S., Lopes, R.V., Ripeanu, M.: Assessing data deduplication trade-offs from an energy and performance perspective. In: 2011 International Green Computing Conference and Workshops. (2011) 1–6
  14. Costa, L.B., Ripeanu, M.: Towards Automating the Configuration of a Distributed Storage System. In: 11th ACM/IEEE Int. Conf. on Grid Computing - Grid 2010. (October 2010)
  15. : The network simulator ns2. http://www.isi.edu/nsnam/ns/ (2012)
  16. Casanova, H., Legrand, A., Quinson, M.: Simgrid: a generic framework for large-scale distributed experiments. In: Proceedings of the Tenth International Conference on Computer Modeling and Simulation. (2008) 126–131
  17. Montresor, A., Jelasity, M.: PeerSim: A scalable P2P simulator. In: Proc. of the 9th Int. Conference on Peer-to-Peer (P2P’09). (Sep 2009)
  18. Ghemawat, S., Gobioff, H., Leung, S.T.: The Google File System. In: SOSP ’03: Proceedings of the nineteenth ACM symposium on Operating systems principles, New York, NY, USA, ACM Press (2003) 29–43
  19. Haddad, I.F.: Pvfs: A parallel virtual file system for linux clusters. Linux Journal 2000(80es) (November 2000)
  20. Hartman, J.H., Ousterhout, J.K.: The zebra striped network file system. ACM Trans. Comput. Syst. 13(3) (1995) 274–310
  21. : pNFS. http://www.pnfs.com (2012)
  22. Zhang, Z., Katz, D.S., Wozniak, J.M., Espinosa, A., Foster, I.: Design and analysis of data management in scalable parallel scripting. In: Proceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis. (2012)
  23. : Mosastore. http://mosastore.net
  24. NLANR/DAST: Iperf. http://iperf.sourceforge.net/
  25. Jain, R.: The Art of Computer Systems Performance Analysis. John Wiley & Sons, Inc. (1991)
  26. Shibata, T., Choi, S., Taura, K.: File-access patterns of data-intensive workflow applications and their implications to distributed filesystems. In: Proceedings of the 19th ACM International Symposium on High Performance Distributed Computing, New York, NY, USA, ACM (2010) 746–755
  27. Bharathi, S., Chervenak, A., Deelman, E., Mehta, G., Su, M.H., Vahi, K.: Characterization of scientific workflows. In: Workflows in Support of Large-Scale Science, 2008. WORKS 2008. Third Workshop on. (2008) 1–10
  28. Anderson, E., Spence, S., Swaminathan, R., Kallahalla, M., Wang, Q.: Quickly finding near-optimal storage designs. ACM Trans. Comput. Syst. 23(4) (Nov 2005) 337–374
  29. Anderson, E., Hobbs, M., Keeton, K., Spence, S., Uysal, M., Veitch, A.: Hippodrome: Running circles around storage administration. In: In Proceedings of the Conference on File and Storage Technologies, USENIX Association (2002) 175–188
  30. Thereska, E., Salmon, B., Strunk, J.D., Wachs, M., Abd-El-Malek, M., López, J., Ganger, G.R.: Stardust: tracking activity in a distributed storage system. In: SIGMETRICS/Performance. (2006) 3–14
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
14531
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description