John L. Bruno

Scheduling independent tasks to reduce mean finishing time

Sequencing to minimize mean finishing time (or mean time in system) is not only desirable to the user, but it also tends to minimize at each point in time the storage required to hold incomplete tasks. In this paper a deterministic model of independent tasks is introduced and new results are derived which extend and generalize the algorithms known for minimizing mean finishing time. In addition to presenting and analyzing new algorithms it is shown that the most general mean-finishing-time problem for independent tasks is polynomial complete, and hence unlikely to admit of a non-enumerative solution.

Single machine flow-time scheduling with a single breakdown

SummaryWe consider the problem of scheduling tasks on a single machine to minimize the flowtime. The machine is subject to breakdowns during the processing of the tasks. The breakdowns occur at a random times and the machine is unavailable until it is repaired. The times for repair are random and independent of each other and of the breakdown process. A task that is preempted due to a breakdown must be restarted and otherwise preemptions are not allowed. We show in the case of a single breakdown that if the distribution function of the time to breakdown is concave then Shortest Processing Time (SPT) first scheduling stochastically minimizes the flowtime. For the case of multiple breakdowns we show that SPT minimizes the expected flowtime when the times to breakdown are exponentially distributed. If the time for a single breakdown is known before scheduling begins, and the processing times of the tasks are also known, then we show that the problem of deciding whether there is a schedule with flowtime less than or equal to a given value is NP-complete. Finally, we bound the performance of SPT scheduling in the deterministic case when there is a single breakdown.

Complexity of Task Sequencing with Deadlines, Set-Up Times and Changeover Costs

In this paper we consider the problem of sequencing classes of tasks with deadlines in which there is a set-up time or a changeover cost associated with switching from tasks in one class to another. We consider the case of a single machine and our results delineate the borderline between polynomial-solvable and

Code Generation for a One-Register Machine

NP

Introducing concurrency to a sequential language

-complete versions of the problem. This is accomplished by giving polynomial time reductions, pseudo-polynomial time algorithms and polynomial time algorithms for various restricted cases of these problems.

Probabilistic bounds for dual bin-packing

The majority of computers that have been built have performed all computations in devices called accumulators, or registers. In this paper, it is shown that the problem of generating minimal-length code for such machines is hard in a precise sense; specifically it is shown that the problem is NP-complete. The result is true even when the programs being translated are arithmetic expressions. Admittedly, the expressions in question can become complicated.

A Theory of Asynchronous Control Networks

We introduce concurrency to the object-oriented language Eiffel through a set of Clans Libraries and an associated concurrent programming design method. This concurrency mechanism is well suited for client/server style distributed applications. The essential principles of sequential object-oriented programming offered by Eiffel are not sacrificed, since no changes are made to the Eiffel Language [19], or its run-time system. Our concurrency abstractions are presented as encapsulated behavior of Eiffel objects that can be inherited from the CONCURRENCY Class

Probabilistic bounds on the performance of list scheduling

SummaryThe problem called dual bin-packing is: given a set of n piece sizes and a fixed number m of unit capacity bins, pack as many pieces as possible into the bins. The problem is NP-complete; an heuristic is known that achieves 6/7 of the optimal number of pieces in all cases. Here we study the first fit increasing heuristic under the assumption that piece sizes are chosen uniformly from [0,1]. We show that, given a desired degree of confidence 1-ε, if n piece sizes ¯X = (X1,..., Xn) are chosen uniformly, then

Relative serializability (extended abstract): an approach for relaxing the atomicity of transactions

P\left[ {\frac{{OPT(\bar X)}}{{FFI(\bar X)}} < 1 + O\left( {\frac{1}{{\sqrt n }}} \right)} \right] \geqq 1 - \varepsilon