Job Lengths Research Articles

Mean-field fluctuations at diffusion scale in threshold-based randomized routing for processor sharing systems and applications

In this article, we study the fluctuations of the empirical occupation measures of servers around their mean-field limit in a large system of heterogeneous processor sharing servers. It is assumed that there are M different servers grouped by their speeds and that the total number of servers is N. In particular, we study the sensitivity of the fluctuations to arrival rate parameters at the diffusion scale. The job arrival process is assumed to be Poisson with rate N ( λ − β N ) and the job lengths are assumed to be exponentially distributed with unit mean. On arrival, a finite number of servers from each group are selected and the destination server depends on the server occupancy normalized to their speeds and pre-defined thresholds, referred to as the Join-Below-Threshold scheme. We derive Functional Central Limit Theorems (FCLTs) for the fluctuations that enable us to estimate the error of the mean-field approximations to the empirical measures associated with a system with N servers. We then use these results to show mean response time for finite systems can be approximated by the response time given by the mean-field limit and the error is O ( 1 N ) for which the constants can be precisely calculated.

Dynamic Bin Packing with Predictions

The MinUsageTime Dynamic Bin Packing (DBP) problem aims to minimize the accumulated bin usage time for packing a sequence of items into bins. It is often used to model job dispatching for optimizing the busy time of servers, where the items and bins match the jobs and servers respectively. It is known that the competitiveness of MinUsageTime DBP has tight bounds of Θ(√łog μ ) and Θ(μ) in the clairvoyant and non-clairvoyant settings respectively, where μ is the max/min duration ratio of all items. In practice, the information about the items' durations (i.e., job lengths) obtained via predictions is usually prone to errors. In this paper, we study the MinUsageTime DBP problem with predictions of the items' durations. We find that an existing O(√łog μ )-competitive clairvoyant algorithm, if using predicted durations rather than real durations for packing, does not provide any bounded performance guarantee when the predictions are adversarially bad. We develop a new online algorithm with a competitive ratio of minØ(ε^2 √łog(ε^2 μ) ), O(μ) (where ε is the maximum multiplicative error of prediction among all items), achieving O(√łog μ) consistency (competitiveness under perfect predictions where ε = 1) and O(μ) robustness (competitiveness under terrible predictions), both of which are asymptotically optimal.

TIGHT-TARDY PROGRESSIVE IDLING-FREE 1-MACHINE PREEMPTIVE SCHEDULING WITH JOB PRIORITY WEIGHTS BY HEURISTIC’S EFFICIENT JOB ORDER INPUT

Background. In setting a problem of minimizing total weighted tardiness by the heuristic based on remaining available and processing periods, there are two opposite ways to input the data: the job release dates are given in either ascending or descending order. It was recently ascertained that scheduling a few equal-length jobs is expectedly faster by ascending order, whereas scheduling 30 to 70 equal-length jobs is 1.5 % to 2.5 % faster by descending order. For the number of equal-length jobs between roughly 90 and 250, the ascending job order again results in shorter computation times. In the case when the jobs have different lengths, the significance of the job order input is much lower. On average, the descending job order input gives a tiny advantage in computation time. This advantage decreases as the number of jobs increases. Objective. The goal is to ascertain whether the job order input is significant in scheduling by using the heuristic for the case when the jobs have different lengths with job priority weights. Job order efficiency will be studied on tight-tardy progressive idling-free 1-machine preemptive scheduling. Methods. To achieve the said goal, a computational study is carried out with a purpose to estimate the averaged computation time for both ascending and descending orders of job release dates. First, the computation time for the ascending job order input is estimated for a series of job scheduling problems. Then, in each instance of this series, job lengths, priority weights, release dates, and due dates are reversed making thus the respective instance for the descending job order input, for which computation time is estimated as well. Results. The significance of the job order input is much lower than that for the case of jobs without priorities. With assigning the job priority weights, the job order input becomes further “dithered”, adding randomly scattered priority weights to randomly scattered job lengths and partially randomized due dates. On average, the descending job order input is believed to give a tiny advantage in computation time in scheduling up to 100 jobs. However, this advantage, if any (being tinier than that in the case of random job lengths without priorities), quickly vanishes as the number of jobs increases. Conclusions. It is better to compose job scheduling problems which would be closer to the case with equal-length jobs without priorities, where the saved computational time can be counted in hours. Even if the job lengths and priority weights are scattered, it is recommended to artificially “flatten” them. When artificial manipulations over job processing periods and job priority weights are impossible, it is recommended to use the descending job order input in scheduling up to 100 jobs, and either job order input in scheduling more than 100 jobs, although substantial benefits are not expected in this case.

Makespan minimization on unrelated parallel machines with simple job-intersection structure and bounded job assignments

Let there be a set J of n jobs and a set M of m parallel machines, where each job Jj takes pi,j∈Z+ time units on machine Mi and assume pi,j=∞ implies job Jj cannot be scheduled on machine Mi. In makespan minimization on unrelated parallel machines (R||Cmax), the goal is to schedule each job non-preemptively on a machine so as to minimize the makespan. A job-intersection graph GJ=(J,EJ) is an unweighted undirected graph where there is an edge {Jj,Jj′}∈EJ if there is a machine Mi such that both pi,j≠∞ and pi,j′≠∞. In this paper we consider two variants of R||Cmax where there are a small number of eligible jobs per machine. First, we prove that there are no approximation algorithms with approximation ratios less than 3/2 for R||Cmax when restricted to instances with job-intersection graphs belonging to some graph classes such as diamondless graphs and planar graphs, unless P=NP. Second, we match this lower bound by presenting a 3/2-approximation algorithm for R||Cmax restricted to instances with diamondless job-intersection graphs, and furthermore show that when GJ is triangle free R||Cmax is solvable in polynomial time. For R||Cmax restricted to instances when every machine can process at most ℓ jobs, we give an approximation algorithm with approximation ratios 3/2 and 5/3 for ℓ=3 and ℓ=4 respectively, a polynomial-time algorithm when ℓ=2, and prove that it is NP-hard to approximate the optimum solution within a factor less than 3/2 when ℓ≥3. In the special case where every pi,j∈{pj,∞}, called the restricted assignment problem, and there are only two job lengths pj∈{α,β} we present a (2−1/(ℓ−1))-approximation algorithm when ℓ≥3. In addition, we give a 2-approximation algorithm for the so-called unrelated graph balancing problem for ℓ=3 in the case where J is partitioned into b sets called bags, and no two jobs from the same bag can be scheduled on the same machine.

Delay-Optimal Scheduling of VMs in a Queueing Cloud Computing System with Heterogeneous Workloads

This paper studies virtual machine (VM) scheduling in a queueing cloud computing system with stochastical arrivals of heterogeneous jobs by considering jobs’ delay requirements. The delay-optimal VM scheduling in such a cloud computing system is formulated as a multi-resource multi-class problem minimize the average job completion time, which is often NP-hard. To solve such a problem, we first propose a queueing model that buffers the same type of VM jobs in one virtual queue. The queueing model then divides the VM scheduling into two parallel low-complexity algorithms, i.e., intra-queue buffering and inter-queue scheduling. A min-min best fit (MM-BF) policy is used to schedule the jobs in different queues to minimize the remaining system resources, while a shortest-job-first (SJF) policy is used to buffer the job requests in each queue based on their job lengths in an ascending order. To avoid job starvation for the long-duration jobs in SJF-MMBF, we further propose a queue-length-based MaxWeight (QMW) policy based on Lyapunov drift to minimize the queue lengths of VM jobs, which is called SJF-QMW. Simulation results show that, SJF-MMBF and SJF-QMW achieve low delay performance in terms of average job completion time and high throughput performance in terms of job hosting ratio.

High-multiplicity election problems

The computational study of elections generally assumes that the preferences of the electorate come in as a list of votes. Depending on the context, it may be much more natural to represent the list succinctly, as the distinct votes of the electorate and their counts, i.e., high-multiplicity representation. We consider how this representation affects the complexity of election problems. High-multiplicity representation may be exponentially smaller than standard representation, and so many polynomial-time algorithms for election problems in standard representation become exponential-time. Surprisingly, for polynomial-time election problems, we are often able to either adapt the same approach or provide new algorithms to show that these problems remain polynomial-time in the high-multiplicity case; this is in sharp contrast to the case where each voter has a weight, where the complexity usually increases. In the process we explore the relationship between high-multiplicity scheduling and manipulation of high-multiplicity elections. And we show that for any fixed set of job lengths, high-multiplicity scheduling on uniform parallel machines is in P, which was previously known for only two job lengths. We did not find any natural case where a polynomial-time election problem does not remain in P when moving to high-multiplicity representation. However, we found one natural NP-hard election problem where the complexity does increase, namely winner determination for Kemeny elections.

The Mean-field Behavior of Processor Sharing Systems with General Job Lengths Under the SQ(d) Policy

In this paper, we derive the mean-field behavior of empirical distributions of large systems that consist of N (large) identical parallel processor sharing servers with Poisson arrival process having intensity Nλ and generally distributed job lengths under the randomized SQ(d) load balancing policy. Under this policy, an arrival is routed to the server with the least number of progressing jobs among d randomly chosen servers. The mean-field is then used to approximate the statistical properties of the system. In particular, we show that in the limit as N grows, individual servers are statistically independent of others (propagation of chaos) and more importantly, the equilibrium point of the mean-field is insensitive to the job length distributions. This has important engineering relevance for the robustness of such routing policies that are often used in web server farms. We use a measure-valued process approach and martingale techniques to obtain our results. We also provide numerical results to support our analysis.

The mean-field behavior of processor sharing systems with general job lengths under the SQ([formula omitted]) policy

This paper addresses the mean-field behavior of large-scale systems of parallel servers with a processor sharing service discipline when arrivals are Poisson and jobs have general service time distributions when an SQ(d) routing policy is used. Under this policy, an arrival is routed to the server with the least number of progressing jobs among d randomly chosen servers. The limit of the empirical distribution is then used to study the statistical properties of the system. In particular, this shows that in the limit as N grows, individual servers are statistically independent of others (propagation of chaos) and more importantly, the equilibrium point of the mean-field is insensitive to the job length distributions that has important engineering relevance for the robustness of such routing policies used in web server farms. We use a framework of measure-valued processes and martingale techniques to obtain our results. We also provide numerical results to support our analysis.

Approximation algorithms for the graph balancing problem with two speeds and two job lengths

Consider a set of n jobs and m uniform parallel machines, where each job has a length \(p_j \in {\mathbb {Q}}^+\) and each machine has a speed \(s_i \in {\mathbb {Q}}^+\). The goal of the graph balancing problem with speeds is to schedule each job j non-preemptively on one of a subset \({\mathcal {M}}_j\) of at most 2 machines so that the makespan is minimized. This is a \(\textsf {NP}\)-hard special case of the makespan minimization problem on unrelated parallel machines, where for the latter a longstanding open problem is to find an approximation algorithm with approximation ratio better than 2. Our main contribution is an approximation algorithm for the graph balancing problem with two speeds and two job lengths with approximation ratio \((\sqrt{65}+7)/8 \approx 1.88278\). In addition, we consider when every \({\mathcal {M}}_j\) has no cardinality constraints, this is the restricted assignment problem in the uniform parallel machine setting. We present a simple \((2-\alpha /\beta )\)-approximation algorithm in this case when every job has one of two job lengths \(p_j \in \{\alpha , \beta \}\) where \(\alpha < \beta \).

Theoretical and Empirical Comparison of Big Data Image Processing with Apache Hadoop and Sun Grid Engine.

The field of big data is generally concerned with the scale of processing at which traditional computational paradigms break down. In medical imaging, traditional large scale processing uses a cluster computer that combines a group of workstation nodes into a functional unit that is controlled by a job scheduler. Typically, a shared-storage network file system (NFS) is used to host imaging data. However, data transfer from storage to processing nodes can saturate network bandwidth when data is frequently uploaded/retrieved from the NFS, e.g., "short" processing times and/or "large" datasets. Recently, an alternative approach using Hadoop and HBase was presented for medical imaging to enable co-location of data storage and computation while minimizing data transfer. The benefits of using such a framework must be formally evaluated against a traditional approach to characterize the point at which simply "large scale" processing transitions into "big data" and necessitates alternative computational frameworks. The proposed Hadoop system was implemented on a production lab-cluster alongside a standard Sun Grid Engine (SGE). Theoretical models for wall-clock time and resource time for both approaches are introduced and validated. To provide real example data, three T1 image archives were retrieved from a university secure, shared web database and used to empirically assess computational performance under three configurations of cluster hardware (using 72, 109, or 209 CPU cores) with differing job lengths. Empirical results match the theoretical models. Based on these data, a comparative analysis is presented for when the Hadoop framework will be relevant and non-relevant for medical imaging.

Preparation in Context: Comparative Outcomes of Alternative Clergy Training in the ELCA

Training requirements for ordained clergy vary widely between US denominations, but the most common qualifications include the Master of Divinity (MDiv), a 3-year professional degree typically earned in residence full-time at a seminary or school of theology following completion of an undergraduate degree. However, past research has found that denominations with more limited formal training requirements for clergy tend to grow more rapidly and that professionalized clergy may actually contribute to denominational decline. I test this with Cox regression, comparing job lengths of Lutheran (ELCA) pastors with MDiv degrees and those who completed an alternative training program (TEEM) where older students complete less extensive coursework while simultaneously serving a ministry context. TEEM candidates often continue serving in this context upon being ordained. The key finding is a persistent advantage for TEEM program graduates net of demographic controls, regardless of how age and experience are factored in. The advantage is not the result of ongoing embeddedness in a single context, suggesting it may result from a combination of differences in the structure of formal education and the simultaneous contextual application. Both life experience (age) prior to being ordained and experience in ordained ministry also provide some advantage, but the effects are largely limited to MDiv graduates in their first few years of ministry. The results provide further evidence for the promise of alternative ministry preparation programs, and help elaborate previous theories of clergy religious capital.

Approximation Algorithms for Subclasses of the Makespan Problem on Unrelated Parallel Machines with Restricted Processing Times

Let there be m parallel machines and n jobs, where a job j can be scheduled on machine i to take pi,j ∈ Z+ time units. The makespan Cmax is the completion time of a machine that finishes last. The goal is to produce a schedule with all n jobs that has minimum makespan. This is the makespan problem on unrelated parallel machines, denoted as R||Cmax. Assume p, q ∈ Z+ are constants, let A(p, q) = {a ∈ Z+ | p ≤ a ≤ q}. We explore a general NP-hard subclass of R||Cmax when processing times are between p and q inclusive or pi,j =∞ abbreviated as R|pi,j ∈ A(p, q)∪ {∞}|Cmax, where pi,j =∞ means job j cannot be scheduled to machine i. We give a (q/p)-approximation algorithm for R|pi,j ∈ A(p, q) ∪ {∞}|Cmax. As a consequence, we obtain a 2-approximation algorithm for the NP-hard subclass R||Cmax with job lengths 1, 2, or pi,j = ∞. In addition, we prove R||Cmax with job lengths 1, 2, and 3 is NP-hard, and present a 3/2-approximation algorithm for this subclass of R||Cmax.

FUGE: A joint meta-heuristic approach to cloud job scheduling algorithm using fuzzy theory and a genetic method

Job scheduling is one of the most important research problems in distributed systems, particularly cloud environments/computing. The dynamic and heterogeneous nature of resources in such distributed systems makes optimum job scheduling a non-trivial task. Maximal resource utilization in cloud computing demands/necessitates an algorithm that allocates resources to jobs with optimal execution time and cost. The critical issue for job scheduling is assigning jobs to the most suitable resources, considering user preferences and requirements. In this paper, we present a hybrid approach called FUGE that is based on fuzzy theory and a genetic algorithm (GA) that aims to perform optimal load balancing considering execution time and cost. We modify the standard genetic algorithm (SGA) and use fuzzy theory to devise a fuzzy-based steady-state GA in order to improve SGA performance in term of makespan. In details, the FUGE algorithm assigns jobs to resources by considering virtual machine (VM) processing speed, VM memory, VM bandwidth, and the job lengths. We mathematically prove our optimization problem which is convex with well-known analytical conditions (specifically, Karush---Kuhn---Tucker conditions). We compare the performance of our approach to several other cloud scheduling models. The results of the experiments show the efficiency of the FUGE approach in terms of execution time, execution cost, and average degree of imbalance.

Algorithms for testing fault-tolerance of sequenced jobs

We study the problem of testing whether a given set of sequenced jobs can tolerate transient faults. We present efficient algorithms for this problem in several fault models. A fault model describes what types of faults are allowed and specifies assumptions on their frequency. Two types of faults are considered: hidden faults, that can only be detected after a job completes, and exposed faults, that can be detected immediately.First, we give an O(n)-time fault-tolerance testing algorithm, for both exposed and hidden faults, if the number of faults does not exceed a given parameter k.Then we consider the model in which any two faults are separated in time by a gap of length at least Δ, where Δ is at least twice the maximum job length. For exposed faults, we give an O(n)-time algorithm. For hidden faults, we give an algorithm with running time O(n 2), and we prove that if job lengths are distributed uniformly over an interval [0,p max ], then this algorithm’s expected running time is O(n). Our experimental study shows that this linear-time performance extends to other distributions. Finally, we provide evidence that improving the worst-case performance may not be possible, by proving an Ω(n 2) lower bound, in the algebraic computation tree model, on a slight generalization of this problem.

Algorithms for multiprocessor scheduling with two job lengths and allocation restrictions

A variant of the High Multiplicity Multiprocessor Scheduling Problem with C job lengths is considered, in which jobs can be processed only by machines not greater than a given index. When C=2, polynomial algorithms are proposed, for the feasibility version of the problem and for maximizing the number of scheduled jobs.

Scheduling search procedures: The wheel of fortune

Suppose that a player can make progress on n jobs, and her goal is to complete a target job among them, as soon as possible. Unfortunately she does not know what the target job is, perhaps not even if the target exists. This is a typical situation in searching and testing. Depending on the player’s prior knowledge and optimization goals, this gives rise to various optimization problems in the framework of game theory and, sometimes, competitive analysis. Continuing earlier work on this topic, we study another two versions. In the first game, the player knows only the job lengths and wants to minimize the completion time. A simple strategy that we call wheel-of-fortune (WOF) is optimal for this objective. A slight and natural modification, however makes this game considerably more difficult: If the player can be sure that the target is present, WOF fails. However, we can still construct in polynomial time an optimal strategy based on WOF. We also prove that the tight absolute bounds on the expected search time. In the final part, we study two competitive-ratio minimization problems where either the job lengths or the target probabilities are known. We show their equivalence, describe the structure of optimal strategies, and give a heuristic solution.

General Perfectly Periodic Scheduling

In a perfectly periodic schedule, each job must be scheduled precisely every some fixed number of time units after its previous occurrence. Traditionally, motivated by centralized systems, the perfect periodicity requirement is relaxed, the main goal being to attain the requested average rate. Recently, motivated by mobile clients with limited power supply, perfect periodicity seems to be an attractive alternative that allows clients to save energy by reducing their "busy waiting" time. In this case, clients may be willing to compromise their requested service rate in order to get perfect periodicity. In this paper we study a general model of perfectly periodic schedules, where each job has a requested period and a length; we assume that m jobs can be served in parallel for some given m. Job lengths may not be truncated, but granted periods may be different than the requested periods. We present an algorithm which computes schedules such that the worst-case proportion between the requested period and the granted period is guaranteed to be close to the lower bound. This algorithm improves on previous algorithms for perfect schedules in providing a worst-case guarantee rather than an average-case guarantee, in generalizing unit length jobs to arbitrary length jobs, and in generalizing the single-server model to multiple servers.

Changes in Job Duration in Canada

Using monthly data from the Canadian Labour Force Survey, the author investigates changes in the complete duration of new job spells from 1981 through 1996. While the average complete length of new jobs did not increase or decrease over the period, investigation of the distribution of complete job lengths reveals two important changes. First, the probability that a new job would end within 6 months rose during the 1980s, but then reversed during the 1990s, meaning that there was important change over the period as a whole. Second, the conditional probability that a job that had lasted 6 months would continue on past 5 years rose through the whole period. This pattern of change was found among virtually all demographic subgroups examined, suggesting that an economy-wide (rather than a sectoral or demographic) explanation must be sought.

SPT is optimally competitive for uniprocessor flow

We show that the Shortest Processing Time (SPT) algorithm is ( Δ+1)/2-competitive for nonpreemptive uniprocessor total flow time with release dates, where Δ is the ratio between the longest and shortest job lengths. This is best possible for a deterministic algorithm and improves on the ( Δ+1)-competitive ratio shown by Epstein and van Stee using different methods.

Multicoloring trees

Scheduling jobs with pairwise conflicts is modeled by the graph multicoloring problem. It occurs in two versions: in the preemptive case, each vertex may get any set of colors, while in the non-preemptive case, the set of colors assigned to each vertex has to be contiguous. We study these versions of the multicoloring problem on trees, under the sum-of-completion-times objective. In particular, we give a quadratic algorithm for the non-preemptive case, and a faster algorithm in the case that all job lengths are short, while we present a polynomial-time approximation scheme for the preemptive case.