Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/arc-w/core-scheduling

Core Scheduling: Minimizing Energy with Deadlines and Dependency Cycles
https://github.com/arc-w/core-scheduling

cpp

Last synced: 12 months ago
JSON representation

Core Scheduling: Minimizing Energy with Deadlines and Dependency Cycles

Awesome Lists containing this project

README 

          
This project is homework from my university. The code is my solution. Here is the description:  

# Core Scheduling: Minimizing Energy with Deadlines and Dependency Cycles

Introduction

Modern computing systems often feature multiple processing cores with varying performance

characteristics (speed) and power consumption rates. Efficiently scheduling tasks across these

heterogeneous cores is crucial, especially in real-time systems where tasks must be completed by

specific deadlines. A primary goal in mobile and embedded systems is to minimize energy

consumption while guaranteeing that all tasks meet their timing constraints and respect any

dependencies between them.  

You are tasked with developing a scheduler for a set of computational tasks that need to be

executed on a system with multiple heterogeneous cores. Each task has a defined computational

workload, a deadline by which it must be completed, and potential dependencies on other tasks.

Each core type has a specific processing speed and a power consumption rate (energy consumed

per unit of time).  

The goal is to find a schedule (an assignment of each task to a core, along with a start and end

time) that minimizes the total energy consumed by all cores while ensuring:  

1. Dependency Constraints:

If Task A must complete before Task B can start (denoted A -> B), the scheduled end

time of Task A must be less than or equal to the scheduled start time of Task B. Tasks and

their dependencies can be modeled as a directed graph.  

2. Deadline Constraints:

Every task must be completed on or before its specified deadline.  

3. Core Constraints:

A single core can only execute one task at a time.  

Dependency Graph Analysis

Task dependencies should ideally form a Directed Acyclic Graph (DAG). However,

configuration errors or specific system models might introduce cycles. Before attempting

scheduling, you must analyze the task dependency graph to detect any cyclic dependencies.  

● Graph Traversal: Techniques that systematically traverse the graph are required to

identify strongly connected components or back-edges, which indicate cycles.  

● Direct Mutual Dependency (2-Cycle): If the analysis reveals exactly two tasks, say Task

A and Task B, forming a direct mutual dependency (A -> B and B -> A), this represents a

special constraint. These two tasks must be scheduled to start at the exact same time, but

on different cores. This parallel execution constraint overrides the standard finish-to-start

dependency between only these two tasks. All other dependencies involving Task A or

Task B must still be respected. If this parallel execution is impossible (e.g., not enough

cores, violates deadlines, or conflicts with other dependencies), then no valid schedule

exists.  

● Larger Cycles: If a cycle involves three or more tasks, a valid schedule satisfying all

constraints is considered impossible.  

Finding the Minimum Energy Schedule  

If the dependency graph is valid (either a DAG or contains only resolvable 2-cycles), you need to

find the schedule with the minimum total energy.  

● State-Space Exploration: Consider the process of building a schedule step-by-step. A

partial schedule can be thought of as a "state," perhaps defined by the set of completed

tasks and the times when each core becomes available next. Finding the optimal schedule

involves exploring this space of possible states.  

● Systematic Search: A systematic search strategy is needed to explore these states. Since

the goal is minimum energy, the search should prioritize exploring states that have

resulted in lower accumulated energy consumption so far.  

● Cost Tracking: Maintaining the minimum energy cost found to reach each distinct state

is crucial to avoid redundant work and ensure optimality.  

● Efficient Exploration: The number of possible states can be large. Employing a data

structure that allows efficient retrieval of the most promising (lowest-energy) state to

explore next is highly recommended for performance.  

Energy Calculation  

● The execution time of a task on a specific core is calculated as: Task Workload / Core

Speed  

● The energy consumed by a task on a specific core is: Execution Time * Core Power Rate  

● The total energy for a schedule is the sum of the energy consumed by all tasks  

Input Format  

Input will be provided via a text file named input.txt with the following structure:  

N # Number of tasks  

Task Info (N lines): TaskID Workload Deadline  

T1_ID T1_Workload T1_Deadline  

T2_ID T2_Workload T2_Deadline  

...  

TN_ID TN_Workload TN_Deadline  

M # Number of dependencies  

Dependency Info (M lines): From_TaskID To_TaskID  

Dep1_From Dep1_To  

Dep2_From Dep2_To  

...  

DepM_From DepM_To  

K # Number of core types  

Core Info (K lines): CoreSpeed CorePowerRate  

Core1_Speed Core1_PowerRate  

Core2_Speed Core2_PowerRate  

● N, M, K - positive integers  

● TaskIDs are positive integers (not necessarily sequential).  

● Workload, Deadline, CoreSpeed, CorePowerRate - positive floating-point numbers.  

● Dependencies are specified using the original TaskIDs.  

● Core types are implicitly assigned IDs 0, 1, ..., K-1 based on their order in the input.  

Output Format  

Your program should output the results to the standard output.  

Cycle Detection Output:  

● Before other output, print messages related to cycle detection as described above

(warnings for cycles, confirmation of DAG status). Use standard error for warnings and

standard output for the DAG confirmation message. Ensure output buffers are flushed

appropriately so these messages appear in the correct order relative to subsequent output.  

Example warning:  

 Warning: Cycle detected involving tasks (1-based IDs): { 2, 1 }  

● If cycles are detected, indicate the attempt to proceed:

 Attempting to schedule based on special cycle handling rules.  

Scheduling Results:  

● If a valid schedule is found:  

○ Print the minimum total energy: Minimum Total Energy Consumed: XXX.XX  

○ Print the schedule table and the details for each task (Task ID, Core ID, Start  

Time, End Time, Energy)

● If no valid schedule is found:  

 Scheduling failed. No solution found that meets all deadlines.