Heterogeneous Earliest Finish Time

Algorithm

HEFT executes in two phases.

Prioritizing tasks

In the first phase each task is given a priority. The priority of each task n i is usually designated to be its "upward rank" which is defined recursively as follows

r a n k u ( n i ) = w i ¯ + max n j ∈ s u c c ( n i ) ( c i , j ¯ + r a n k u ( n j ) )

where n i represents the i t h task, w i ¯ is an average computation cost of job i among all the workers, s u c c ( n i ) is the set of all jobs that immediately depend on task n i , and c i , j ¯ is the average communication cost of the variables transferred between jobs n i and n j between all pairs of workers. Note that the computation of r a n k u ( n i ) depends on the computation of the rank of all its children. The upward rank is meant to represent the expected distance of any task from the end of the computation. For averaged quantities like w i ¯ different averages may provide different results.

Assigning tasks to workers

In the second phase tasks are assigned to workers. Now that all tasks are prioritized we consider and schedule each one, starting with the highest priority. The task with the highest priority for which all dependent tasks have finished is scheduled on the worker which will result in the earliest finish time of that task. This finish time depends on the communication time to send all necessary inputs to the worker, the computation time of the task on the worker, and the time when that processor becomes available (it may be busy with another task).

Performance

HEFT is well respected among heuristic algorithms for this problem. However, in complex situations it can easily fail to find the optimal scheduling. HEFT is essentially a greedy algorithm and incapable of making short-term sacrifices for long term benefits.

Code

A Python implementation of HEFT is available on github