Unified Computation and Global Synchronization Scheduling

• Unified Computation/Global Synchronization Scheduling is a framework that integrates parallel execution and system-wide synchronization to achieve deterministic operation in real-time multiprocessor systems.
• It employs a canonical greedy algorithm that assigns mandatory and fractional processor allocations to tasks while ensuring deadlines are met under a strict utilization bound.
• By modeling sublinear speedup and minimizing migrations, the framework optimally balances workload, processor resources, and synchronization overhead.

Unified Computation/Global Synchronization Scheduling refers to the coordinated allocation and execution of computational resources and global synchronization mechanisms with the goal of achieving time-deterministic, resource-optimal, and deadline-compliant operation, typically in multiprocessor and distributed real-time environments. Within this paradigm, both computation (potentially including parallel and partitioned execution models) and system-wide synchronization events are scheduled by a unified policy informed by detailed feasibility, resource, and workload characteristics. Such approaches are critical for real-time systems, parallel computing, and distributed scheduling where global guarantees must be provided despite variability in task requirements and execution environments.

1. Multiprocessor Real-Time Scheduling with Integrated Job Parallelism

A foundational model for unified computation/global synchronization scheduling is provided in the theory of real-time task systems integrating job parallelism on multiprocessors (0805.3237). In this model, each sporadic real-time task τᵢ is characterized by its period Tᵢ, worst-case execution time Cᵢ, and a work profile Γᵢ = (γᵢ,₁, γᵢ,₂, …, γᵢ,ₘ), where γᵢ,ⱼ quantifies the progress per time unit if the job is executed on j processors simultaneously. The system explicitly incorporates realistic “work-limited” speedup, formalized as

$$(j'/j) > (\gamma_{i,j'})/(\gamma_{i,j}) \quad \text{and} \quad \gamma_{i,j'+1} - \gamma_{i,j'} \leq \gamma_{i,j+1} - \gamma_{i,j},$$

which enforces sublinear scaling as processors are added and captures diminishing returns due to synchronization overheads or communication.

An optimal scheduling algorithm is constructed by, for each task τᵢ, determining the minimal parallelism index $k_i$ such that $u_i = C_i/T_i > \gamma_{i,k_i}$, and allocating $k_i$ processors fully with an additional processor fractionally for time $\ell_i$:

$$\ell_i = \frac{u_i - \gamma_{i,k_i}}{\gamma_{i,k_i+1} - \gamma_{i,k_i}}.$$

This splits the task's execution uniformly between the base allocation and an occasional boost, with the feasibility condition

$\sum_{i=1}^n \left[k_i + \ell_i\right] \leq m,$

offering a necessary and sufficient utilization bound. The schedule is globally synchronized: assignments are periodic with a period of 1, ensuring deterministic operation and directly supporting global synchronization requirements.

2. Canonical Scheduling Algorithm

The canonical scheduling algorithm exploits a monotone, greedy assignment of processor intervals to tasks in fixed order (typically decreasing task index). Each task is statically assigned $k_i$ base processors, and any residual workload is mapped to the minimal additional time window on an extra processor. For each processor, this schedule is periodic and monotonic, with wrap-around behavior for the fractional assignment. Construction time is $O(n)$ for fixed $m$.

The resulting schedule is globally synchronized: all tasks and their assignments repeat every unit interval, and all job deadlines are met so long as the feasibility bound holds. The schedule is optimal if preemptions and migrations are neglected.

3. Model-Based Integration of Parallelism and Global Synchronization

By encoding per-task parallelism via $Γ_i$ and enforcing work-limited scaling, this framework allows partial parallelism: jobs may execute both in serial and in parallel over fractional intervals. The scheduling approach unifies both computation and global timing by balancing resource allocations—the extra “processor-time” needed due to parallelism is precisely accounted for in feasibility analysis and schedule construction. The sublinear benefit enforced by the model ensures that exploiting parallelism comes at a calculable processor-time cost, integrating synchronization considerations directly into computation resource allocation.

4. Minimizing Migrations and Preemptions in Multiprocessor Scheduling

While global scheduling is processor-optimal, it inherently introduces task migrations (movement across processors) and preemptions (context switches), particularly for tasks whose execution alternates between base and additional processors. To limit run-time overhead, a reduction strategy is proposed:

• Statistically assign each task to its $k_i$ base (mandatory) processors for each time interval.
• Define a reduced task set $τ'$ by stripping away these base assignments, where each residual task $τ_i’$ has execution requirement $C_i’ = \ell_i T_i$.
• Schedule the reduced set on the remaining $m' = m - \sum_i k_i$ processors using existing algorithms (e.g., global EDF, partitioned scheduling).

This decomposition results in drastically reduced migrations and preemptions, as most work is statically assigned, and only a small fractional component per task remains to be globally scheduled. The approach preserves overall system feasibility and optimality.

5. Relationship to Classical Bounds and Practical Implications

The feasibility bound in this job-parallelism-integrated framework generalizes the classical Liu & Layland [1973] uniprocessor utilization bound. When $m=1$ and $Γ_i$ encodes only single-processor performance, the model reduces to the well-known $\sum_i u_i \leq 1$ bound.

Pragmatically, this means that real-time multiprocessor systems can be scheduled with fine-grained, globally periodic allocation, addressing both computation and synchronization requirements. By precisely modeling the trade-off between parallel speedup and processor-time cost, system designers can tune the degree of parallelism for each task to maximize throughput and minimize processor over-provisioning, while limiting overhead from synchronization primitives. Moreover, by employing the problem reduction technique, run-time inefficiencies due to migration and preemption can be analytically controlled.

6. Summary Table: Key Elements of the Unified Scheduling Framework

Feature	Description	Implementation
Task Work Model	$\Gamma_i = (\gamma_{i,1}, ..., \gamma_{i,m})$ (progress per # processors)	Per task
Parallelism Assignment	$k_i, \ell_i$ (mandatory + fractional processor allocation per unit interval)	Per task
Feasibility Bound	$\sum_i [k_i + \ell_i] \leq m$	System-wide
Canonical Schedule	Periodic assignment: $k_i$ full, $1$ partial processor	Greedy, $O(n)$
Migration/Preemption Limitation	Reduce residuals, assign statically, schedule leftovers via non-parallel methods	Algorithmic

This framework rigorously integrates job parallelism into real-time multiprocessor scheduling, deriving a globally synchronized, utilization-optimal periodic schedule with bounded migration and preemption, thereby unifying computation and global synchronization requirements in theory and practice (0805.3237).