Program-based static allocation policies for highly parallel computers

Multiprocessor scheduling in a shared multiprogramming environment can be structured as two-level scheduling, where a kernel-level job scheduler allots processors to jobs and a user-level thread scheduler schedules the work of a job on its allotted processors. We present a randomized work-stealing thread scheduler for fork-join multithreaded jobs that provides continual parallelism feedback to the job scheduler in the form of requests for processors. Our A-STEAL algorithm is appropriate for large parallel servers where many jobs share a common multiprocessor resource and in which the number of processors available to a particular job may vary during the job's execution. Assuming that the job scheduler never allots a job more processors than requested by the job's thread scheduler, A-STEAL guarantees that the job completes in near-optimal time while utilizing at least a constant fraction of the allotted processors. We model the job scheduler as the thread scheduler's adversary, challenging the thread scheduler to be robust to the operating environment as well as to the job scheduler's administrative policies. For example, the job scheduler might make a large number of processors available exactly when the job has little use for them. To analyze the performance of our adaptive thread scheduler under this stringent adversarial assumption, we introduce a new technique called trim analysis, which allows us to prove that our thread scheduler performs poorly on no more than a small number of time steps, exhibiting near-optimal behavior on the vast majority. More precisely, suppose that a job has work T 1 and span T ∞ . On a machine with P processors, A-STEAL completes the job in an expected duration of O ( T 1 / P˜ + T ∞ + L lg P ) time steps, where L is the length of a scheduling quantum, and P˜ denotes the O ( T ∞ + L lg P )-trimmed availability. This quantity is the average of the processor availability over all time steps except the O ( T ∞ + L lg P ) time steps that have the highest processor availability. When the job's parallelism dominates the trimmed availability, that is, P˜ < T 1 / T ∞ , the job achieves nearly perfect linear speedup. Conversely, when the trimmed mean dominates the parallelism, the asymptotic running time of the job is nearly the length of its span, which is optimal. We measured the performance of A-STEAL on a simulated multiprocessor system using synthetic workloads. For jobs with sufficient parallelism, our experiments confirm that A-STEAL provides almost perfect linear speedup across a variety of processor availability profiles. We compared A-STEAL with the ABP algorithm, an adaptive work-stealing thread scheduler developed by Arora et al. [1998] which does not employ parallelism feedback. On moderately to heavily loaded machines with large numbers of processors, A-STEAL typically completed jobs more than twice as quickly as ABP, despite being allotted the same number or fewer processors on every step, while wasting only 10% of the processor cycles wasted by ABP.

The problem of optimal scheduling n tasks in a parallel processor system is studied. The tasks are malleable, i.e., a task may be executed by several processors simultaneously and the processing speed of a task is a nonlinear function of the number of processors allocated to it. The total number of processors is m and it is an upper bound on the number of processors that can be used by all the tasks simultaneously. It is assumed that the number of processors is sufficient to process all the tasks simultaneously, i.e. n≤m. The objective is to find a task schedule and a processor allocation such that the overall task completion time, i.e. the makespan, is minimized. The problem is motivated by real-life applications of parallel computer systems in scientific computing of highly parallelizable tasks. An O(n) algorithm is presented to solve this problem when all the processing speed functions are convex. If these functions are all concave and the number of tasks is a constant, the problem can be solved in polynomial time. A relaxed problem, in which the number of processors allocated to each task is not required to be integer, can be solved in O(nmax {m,nlog 2 m}) time. It is proved that the minimum makespan values for the original and relaxed problems coincide. For n=2 or n=3, an optimal solution for the relaxed problem can be converted into an optimal solution for the original problem in a constant time.

Redundancy is an important strategy for reducing response time in multi-server distributed queueing systems. This strategy has been used in a variety of settings, but only recently have researchers begun analytical studies. The idea behind redundancy is that customers can greatly reduce response time by waiting in multiple queues at the same time, thereby experiencing the minimum time across queues. Redundancy has been shown to produce significant response time improvements in applications ranging from organ transplant waitlists to Google’s BigTable service. However, despite the growing body of theoretical and empirical work on the benefits of redundancy, there is little work addressing the questions of how many copies one needs to make to achieve a response time benefit, and the magnitude of the potential gains. In this paper we propose a theoretical model and dispatching policy to evaluate these questions. Our system consists of k servers, each with its own queue. We introduce the Redundancy-d policy, under which each incoming job makes copies at a constant number of servers, d, chosen at random. Under the assumption that a job’s service times are exponential and independent across servers, we derive the first exact expressions for mean response time in Redundancy-d systems with any finite number of servers, as well as expressions for the distribution of response time which are exact as the number of servers approaches infinity. Using our analysis, we show that mean response time decreases as d increases, and that the biggest marginal response time improvement comes from having each job wait in only d = 2 queues. The e-companion is available at https://doi.org/10.1287/opre.2016.1582 .

Cost-Effectiveness Analysis of Potential Improvements to Emergency Medical Services for Victims of Out-of-Hospital Cardiac Arrest

Multi-tiered storage, where each tier comprises one type of storage device, e.g., SSD, HDD, is a commonly used approach to achieve both high performance and cost efficiency in large-scale systems that need to store data with vastly different access characteristics. By aligning the access characteristics of the data to the characteristics of the storage devices, higher performance can be achieved for any given cost. This article presents ExaPlan, a method to determine both the data-to-tier assignment and the number of devices in each tier that minimize the system's mean response time for a given budget and workload. In contrast to other methods that constrain or minimize the system load, ExaPlan directly minimizes the system's mean response time estimated by a queueing model. Minimizing the mean response time is typically intractable as the resulting optimization problem is both non-convex and combinatorial in nature. ExaPlan circumvents this intractability by introducing a parameterized data-placement approach that makes it a highly scalable method that can be easily applied to exascale systems. Through experiments that use parameters from real-world storage systems, such as CERN and LOFAR, it is demonstrated that ExaPlan provides solutions that yield lower mean response times than previous works. It is also capable of determining a data-to-tier assignment both at the level of files and at the level of fixed-size extents. For some of the workloads evaluated, file-level placement exhibited a significant performance improvement over extent-level placement.

While the performance of individual disks is well understood, the performance of disk arrays configured as redundant arrays of independent disks - RAID requires further investigation. We report on a tool that can be used for the performance evaluation of k disk failure tolerant (kDFT) disk arrays. RAID0 is a 0DFT. RAID5 is a 1DFT utilizing a single check disk. RAID6, EVENODD, and RDP are 2DFTs with two check disks and a minimum level of redundancy, while RM2 is a 2DFT with a slightly higher redundancy level. The capacity overhead is less important for high capacity modern disks than the disk access overhead to update parities, especially the small write penalty. Degraded mode operation and rebuild processing incur extra overhead on surviving disks. The RAID level, configuration, operating mode (normal, degraded with 1 or 2 failures, and rebuild mode with various options), and workload characteristics have a significant effect on RAID performance, which can be evaluated using our tool. We consider here only discrete requests and derive cost functions to determine: (a) the volume of data to be transmitted; (b) the maximum attainable throughput for given disk characteristics; (c) the mean response time given the execution plans of RAID operations specified as dags (directed acyclic graphs). Analytic solutions are possible when arrivals are Poisson with the FCFS policy. Some interesting results obtained by the tool are given to illustrate its capabilities.

Addresses the problem of maximizing application speedup through run-time self-selection of an appropriate number of processors on which to run. Automatic run-time selection of processor allocations is important because many parallel applications exhibit peak speedups at allocations that are data- or time-dependent. We propose the use of a run-time system that: (a) dynamically measures job efficiencies at different allocations, (b) uses these measurements to calculate speedups, and (c) automatically adjusts a job's processor allocation to maximize its speedup. Using a set of 10 applications that includes both hand-coded parallel programs and compiler-parallelized sequential programs, we show that our run-time system can reliably determine dynamic allocations that match the best possible static allocation, and that it has the potential to find dynamic allocations that outperform any static allocation.

Background: The hospitalist model in obstetric care which was introduced over the last decades now has an important role in care delivery management with the potential positive impact on maternal and neonatal outcomes.Objective: The aim of this study was to evaluate the effect of hospitalist model towards surgical emergency response time.Method: This research design was cohort a retrospective study. Participants included were the patient in the time before and after implementation of obstetrician/gynecologist full-hospitalist policy during October 2013 until September 2014. The outcome measured were mean response time and possible hospital factors which contribute to response time.Result and Discussion: We included a total of 71 patients (30 on-call obstetrician group and 41 full-time hospitalist group). Univariate analysis indicated mean response time was significantly differ in full-time hospitalist group when compared to the on-call obstetrician group (65.3 + 25.89 vs. 84 + 22.29 mins; p = 0.002). Multivariable analysis determined that hospital factors which contribute to response time are readiness of operating theatre.Conclusion: Implementation of full-time hospitalist model is associated with a significant improvement of response time in emergency obstetric care.Keywords: Maternal mortality, Obstetrician/Gynecology Hospitalist, C-section, Response Time

In the field of parallel computing, load balancing of parallel simulations is considered as a fundamental problem. The primary goal is to evenly distribute computing load across multiple processors while minimizing processor-to-processor communication. A prevalent approach to solving the problem of balancing is based on a graph model. To balance the load between k processors, we partition the graph into k parts, each one is assigned to a processor. This problem is difficult to solve, but effective heuristics have been proposed, including those based on a multilevel approach, used by most graph partitioning tools. All partitioning methods are only relevant if the number of processors is fixed. It is essential to choose the right number of processors for a simulation to get good performance and more efficiency.In this paper, we test several graphs partitioning using the metis framework then we try to find the optimal number of processors, named in this paper p* to execute a simulation and the max speed up that we can reach using parallelization. We also investigate the intrinsic graph characteristics that affect these parameters.

Vehicular Cloud Computing (VCC) facilitates real-time execution of many emerging user and intelligent transportation system (ITS) applications by exploiting under-utilized on-board computing resources available in nearby vehicles. These applications have heterogeneous time criticality, i.e., they demand different Quality-of-Service levels. In addition to that, mobility of the vehicles makes the problem of scheduling different application tasks on the vehicular computing resources a challenging one. In this article, we have formulated the task scheduling problem as a mixed integer linear program (MILP) optimization that increases the computation reliability even as reducing the job execution delay. Vehicular on-board units (OBUs), manufactured by different vendors, have different architecture and computing capabilities. We have exploited MapReduce computation model to address the problem of resource heterogeneity and to support computation parallelization. Performance of the proposed solution is evaluated in network simulator version 3 (ns-3) by running MapReduce applications in urban road environment and the results are compared with the state-of-the-art works. The results show that significant performance improvements in terms of reliability and job execution time can be achieved by the proposed task scheduling model.

In a preliminary study a film was designed to shorten the time necessary to perceive the direction of a tennis return. Ss showed significant improvement in response time. Since the training was conducted with individual Ss, the use of the training film in a classroom situation was examined. Results indicated significant improvement in response time; thus the training device appears to be useful in classroom situations.

In the mid 1990s, the grid computing community promised the "compute power grid," a utility computing infrastructure for scientists and engineers. Since then, a variety of grids have been built worldwide, for academic purposes, specific application domains, and general production work. Understanding grid workloads is important for the design and tuning of future grid resource managers and applications, especially in the recent wake of commercial grids and clouds. This article presents an overview of the most important characteristics of grid workloads in the past seven years (2003-2010). Although grid user populations range from tens to hundreds of individuals, a few users dominate each grid's workload both in terms of consumed resources and the number of jobs submitted to the system. Real grid workloads include very few parallel jobs but many independent single-machine jobs (tasks) grouped into single "bags of tasks."

High performance computing offers an excellent vehicle to accelerate computational needs of scientific and engineering applications. These High performance computing applications consists of several processes that communicate frequently. Because of their synchronization needs, these applications suffer from performance penalties if the processes of the applications are not all co scheduled together. Effective Scheduling Strategies to improve response time, throughput, utilization, mean response time, mean reaction time, mean slowdown are an important considerations in parallel systems. Traditionally used many space and time sharing strategies to accommodate multiple jobs at the same time in to a parallel system. However these approaches suffer from low system utilization and large job wait time. The paper concentrates on the detailed frequency granularity of the processes in the application and schedules accordingly. The paper discusses the various algorithms used for the grains sizes and results are compared with the traditional approaches like First Come First Served, Gang Scheduling, Flexible Co scheduling and the results are compared with the help of various performance metrics and analyzed in a detail manner.

Objectives: To examine the performance of a rural ambulance trust during two time periods, 1996/97 and 2001, with respect to achieving standards for ambulance journey times and delivery of clinical...

In this paper, we study the problem of dynamic allocation of heterogeneous processors to parallel heterogeneous job traffic flows. Each traffic flow is a stationary ergodic random marked point process, with a parameter (traffic intensity rate) that depends on the job class. The service rates of the various job flows depend on both the job class and the processor class. This model captures the essential features of several practical systems, including flexible manufacturing ones, packet switches, distribution systems, etc. We first specify precisely the necessary and sufficient condition for stability of the system. We then identify a family of policies that achieves maximum throughput; i.e. they stabilize the system under the maximum possible input rates. The approach taken introduces the concept of virtual queueing, which proves powerful in establishing strong probabilistic results (convergence in distribution to a finite stationary regime) for queueing systems with complex dynamics due to sharing resources, under a very general stationary ergodic probabilistic structure.