In the general form of multiprocessor precedence scheduling problems a set of n tasks to be executed on m processors is given. Each task requires exactly one unit of execution time and can run on any processor. A directed acyclic graph specifies the precedence constraints where an edge from task x to task y means task x must be completed before task y begins. A solution to the problem is a schedule of shortest length indicating when each task is started. The work of Jung, Serna, and Spirakis provides a parallel algorithm (on a PRAM machine) that solves the above problem for the particular case that m = 2, that is where there are two parallel processors.The two processor precedence constraint scheduling problem is defined by a directed acyclic graph (dag) G = (V, E). The vertices of the graph represent unit time tasks, and the edges specify precedence constraints among the tasks. If there is an edge from node x to node y then x is an immediate predecessor of y. Predecessor is the transitive closure of the relation immediate predecessor, and successor is its symmetric counterpart. A two processor schedule is an assignment of the tasks to time units 1, . . . , t so that each task is assigned exactly one time unit, at most two tasks are assigned to the same time unit, and if x is a predecessor of y then x is assigned to a lower time unit than y. The length of the schedule is t. A schedule having minimum length is an optimal schedule. Thus the problem is the following: Name Two processor precedence constraint scheduling Input A directed acyclic graph Output A minimum length schedule preserving the precedence constraints.Preliminaries The algorithm assume that tasks are partitioned into levels as follows: (i) Every task will be assigned to only one level (ii) Tasks having no successors will be assigned to level 1 and (iii) For each level i, all tasks which are immediate predecessors of tasks in level i will be assigned to level i + 1.Clearly topological sort will accomplish the above partition, and this can be done by an NC algorithm that uses O(n 3 ) processors and O(log n) time, see [3]. Thus, from now on, it is assumed that a level partition is given as part of the input. For sake of convenience two special tasks, t 0 and t * are added, in such a way that the original graph could be taught as the graph formed by all tasks that are successors of t 0 and predecessors of t * . Thus t 0 is a predecessor of all tasks in the system