A public safety unit of a university issues identification c

A public safety unit of a university issues identification cards at the beginning of each semester. Every year about 6,000 new ID cards are issued. The steps in the process and the approximate times are given below.

Note: Steps 1 and 2 must be completed first, and Step 6 must be completed last.

Steps in the process                                    Estimated time

1.   Review the application                             15 seconds

2.   Verify information                                    25 seconds

3.   Check student/staff status                        40 seconds

4.   Take photo                                                70 seconds

5.   Attach photo and laminate                       35 seconds

6.   Issue ID                                                    20 seconds

c. Now suppose you have only four workers. Please show how you will re-allocate the tasks to enable maximum possible efficiency, and what will be the maximum number of applications processed with just four workers.

Solution

Deterministic solutions to the task allocation drawback square measure typically primarily based upon
several common concepts. To certify once all tasks are dead, the processes put together maintain a
so-called progress tree [3,13] or another quite organization for pursuit work. every method maintains
its own permutation of the m tasks and executes these tasks within the permutation order. One will read this
approach as generalizing the straightforward case wherever p = 2: one method executes the tasks so as one, 2, 3, . . .,
while the opposite executes the task so as m, m 1, m 2, . . ., and at some purpose within the middle, the two
processes meet. once there square measure p > two processes, the trick is to settle on permutations to hide all the tasks,
regardless of however the operations interleave, whereas at the same time avoiding an excessive amount of redundant work. More
recently, researchers have used expanders to offer algorithms with higher work complexness.
The most economical settled task allocation algorithmic program for general m and p, given by Kowalski and
Shvartsman [22], uses O(m + p
2+
) total work. It uses a group of permutations with low contention; to
date, it\'s not proverbial a way to construct such permutations in polynomial time, so their algorithmic program isn\'t
explicit. the foremost economical specific algorithmic program was given by Malewicz [24], exploitation O(m + p
4
log m) work.
These last 2 algorithms achieved optimum O(m) work for p = O(m1/(2+)
) and p = O((m/ log m)
1/4
),
respectively. against this, our algorithmic program is work-optimal for a wider vary of p = O(m/polylog m).
For the special case once p = m, Chlebus and Kowalski [15] gave a non-explicit settled algorithmic program
with complexness O(m log18 m/(log log m)
3
) and an exact variant with complexness M2
O(log3
log m)
. This
algorithm and its specific variant square measure primarily based upon expander constructions. once applied to m > p their
approach yields O((m+p) polylogm) work. Earlier settled algorithms for the task allocation drawback
appear in, e.g. [3, 17, 18]. In distinction to those higher bounds, there\'s a (m + p log p) boundary [13],
which holds for settled algorithms and for randomised algorithms with a powerful someone.
Randomized solutions to the task allocation drawback square measure primarily based upon the concept of getting processors choose
tasks at random from the whole set of tasks or from the set of tasks that stay to be dead. Most
previous randomised algorithms for the task allocation drawback assumed that the someone is oblivious; associate degree
oblivious (weak) someone is aware of the system state once the algorithmic program begins, however in distinction to the adaptive
adversary, cannot see the outcomes of coin tosses.
Anderson associate degreed Woll [3] gave a randomised algorithmic program that works against an adaptive someone. The algo-
3
rithm assumes p processes, m = p
2
tasks, and runs in O(m log m) work. The algorithmic program is predicated on random
permutations on a special quite progress tree; derandomized variants are studied in [14]. Their strategy,
as written, doesn\'t be general m and p. Since the algorithmic program has complexness (m log m) and
m = p
2
, it runs inside a log issue of optimum. The randomised algorithmic program of Martel et al. [25], which runs
against associate degree oblivious someone, performs work O(m) with high likelihood, exploitation p = m/ log m processes.
Thus, it achieves optimum work for this selection of p and a weak someone. different randomised algorithms for
the oblivious someone embrace [8, 19]. For an in depth summary of analysis on this drawback, we tend to refer the
reader to the book by Giorgiou and Shvartsman [16].
Outline. Section two formalizes the model and definitions employed in the paper. Section three presents our stir
Tree algorithmic program for asynchronous task allocation. Sections four and five analyze the randomised and derandomized
versions of the stir Tree algorithmic program.
2 Definitions and Notations
Model. we tend to assume the classic asynchronous shared-memory model [5, 23] with p processes one, 2, . . . , p,
where up to t < p processes might fail by bloody. every method features a distinct initial symbol i. Processes
communicate through atomic scan and write operations on registers. The programming of the processes’ steps
and crashes is controlled by a powerful adaptive someone. in any respect times the someone is aware of the state of the
entire system, together with the results of random coin flips, and may change the schedule and also the failure pattern
accordingly. Algorithms that square measure correct during this setting square measure known as wait-free.
Problem statement. Asynchronous task allocation suggests that facultative p processes to execute m distinct tasks,
labeled . the standard work complexness metric measures the whole variety of shared-register
operations that processes perform throughout associate degree execution. we tend to conjointly analyze the tasks dead metric, counting
the total variety of times that tasks square measure dead. Note that each one m tasks should be dead a minimum of once, but
some tasks might get dead redundantly. The redundant-task magnitude relation is tasks dead divided by m.