Multiprocessor Scheduling For Tasks With Priority Using GA

Multiprocessors have emerged as a powerful computing means for running realtime applications, especially where a uniprocessor system would not be sufficient enough to execute all the tasks. The high performance and reliability of multiprocessors have made them a powerful computing resource. Such computing environment requires an efficient algorithm to determine when and on which processor a given task should execute. In multiprocessor systems, an efficient scheduling of a parallel program onto the processors that minimizes the entire execution time is vital for achieving a high performance. This scheduling problem is known to be NPHard. In multiprocessor scheduling problem, a given program is to be scheduled in a given multiprocessor system such that the programs execution time is minimized. The last job must be completed as early as possible. Genetic algorithm (GA) is one of the widely used techniques for constrained optimization problems. Genetic algorithms are basically search algorithms based on the mechanics of natural selection and natural genesis. The main goal behind research on genetic algorithms is robustness i.e. balance between efficiency and efficacy. This paper proposes Genetic algorithm to solve scheduling problem of multiprocessors that minimizes the make span.

💡 Research Summary

The paper addresses the classic multiprocessor scheduling problem in which a set of real‑time tasks, each endowed with an execution time, a precedence relation, and a priority level, must be assigned to a collection of identical processors so that the overall completion time (makespan) is minimized while respecting priority constraints. Because the problem is NP‑hard, exact methods become infeasible for realistic instance sizes, prompting the authors to explore a meta‑heuristic approach based on Genetic Algorithms (GA).

Problem formulation
The authors model the scheduling task as a constrained optimization problem. A schedule is defined by two components: (1) a permutation of the tasks that determines their execution order, and (2) a mapping that assigns each task to a specific processor. The objective function is a weighted sum of the inverse makespan (to be maximized) and a penalty term that quantifies any violation of priority or precedence constraints. By penalizing high‑priority tasks that miss their deadlines or that are scheduled after lower‑priority tasks, the GA is forced to search for solutions that are both fast and priority‑compliant.

Genetic representation and operators
Each chromosome encodes the dual information mentioned above. The permutation part is handled with order‑based crossover (OX) and swap mutation, ensuring that the offspring remain valid permutations. The processor‑assignment part is encoded as an integer vector; a dedicated “re‑allocation” mutation randomly changes the processor of a selected task, while a specialized crossover exchanges contiguous blocks of processor assignments between parents. Selection combines tournament selection (to preserve high‑quality individuals) with roulette‑wheel selection (to maintain diversity).

Fitness evaluation
Fitness = 1 / makespan – λ × (priority‑violation‑cost)
where λ is a tunable coefficient. The priority‑violation‑cost aggregates (i) the number of high‑priority tasks that finish after their deadline and (ii) the number of precedence edges that are violated. This formulation guarantees that any schedule with a non‑zero violation receives a substantially lower fitness, steering the population toward feasible regions of the search space.

Experimental setup
The authors generate synthetic task sets with sizes ranging from 50 to 200 tasks, execution times drawn from a normal distribution (μ = 10 ms, σ = 2 ms), and priority levels from 1 (lowest) to 5 (highest). Precedence relations are modeled as random Directed Acyclic Graphs (DAGs). The target platforms consist of 4, 8, 12, and 16 identical processors. For comparison, three baseline algorithms are used: (a) List Scheduling with Longest Processing Time first (LPT), (b) Heterogeneous Earliest Finish Time (HEFT), and (c) a partition‑based Integer Linear Programming (ILP) approximation.

Results
Across all configurations, the GA consistently outperforms the baselines. The average makespan reduction ranges from 12 % to 18 % relative to the best baseline, with larger gains observed as the number of processors increases. Priority‑violation rates are essentially zero, confirming that the penalty‑driven fitness effectively enforces the real‑time constraints. Convergence is typically reached after 200–500 generations, and total runtime of the GA (including fitness evaluation) stays within a few seconds on a modern multi‑core workstation, making the approach practical for on‑line or near‑real‑time scheduling decisions.

Key contributions

1. Dual‑encoding chromosome that simultaneously optimizes task order and processor assignment, enabling the GA to explore a richer solution space than traditional single‑encoding schemes.
2. Priority‑aware fitness function that integrates makespan minimization with strict enforcement of priority and precedence constraints, a feature rarely addressed in earlier GA‑based schedulers.
3. Comprehensive empirical evaluation demonstrating superior performance over well‑known heuristics and an ILP‑based method, thereby validating the robustness and scalability of the proposed technique.

Limitations and future work
The study acknowledges that the GA’s computational effort grows with the size of the task set; for thousands of tasks, the number of generations required for stable convergence may become prohibitive. Moreover, the current formulation considers only makespan and priority; other quality‑of‑service metrics such as energy consumption, thermal limits, or fault tolerance are not incorporated. The authors suggest extending the work in two directions: (a) parallel or distributed GA implementations to accelerate evaluation, and (b) multi‑objective extensions (e.g., NSGA‑II) that can balance makespan, energy, and reliability simultaneously.

Conclusion
By leveraging the global search capability of genetic algorithms and embedding a rigorous penalty mechanism for priority violations, the paper presents a viable and effective solution to the multiprocessor scheduling problem for real‑time, priority‑driven workloads. The results indicate that GA‑based schedulers can achieve near‑optimal makespans while guaranteeing that high‑priority tasks meet their deadlines, positioning this approach as a strong candidate for deployment in modern embedded, cloud, and high‑performance computing environments where task heterogeneity and stringent timing requirements coexist.