Prioritization - Revision history

Dafne: /* Priority Inheritance */

2025-03-25T14:18:00Z

Priority Inheritance

Dafne: /* Priority Inheritance */

2025-03-25T14:16:51Z

Priority Inheritance

Dafne: Created page with "== Task Execution in Processing == During processing, multiple tasks need to be executed in a specific order. This order is not entirely random, nor is it strictly predefined..."

2025-03-25T14:13:25Z

Created page with "== Task Execution in Processing == During processing, multiple tasks need to be executed in a specific order. This order is not entirely random, nor is it strictly predefined..."

New page

== Task Execution in Processing ==

During processing, multiple tasks need to be executed in a specific order. This order is not entirely random, nor is it strictly predefined. At any given time, several tasks can run simultaneously. However, the number of running tasks is constrained not only by task dependencies but also by the load they impose on the database server’s resources.

In typical data warehouse (DWH) processing, most tasks in the staging layer can be executed without waiting for dependencies. For an average-sized DWH, this may involve running hundreds of tasks concurrently. However, such a high number of active tasks can put significant strain on server resources, particularly memory. To prevent excessive resource consumption, it is important to limit the number of tasks running at once.

If the maximum number of allowed tasks is reached, any additional tasks that would exceed the limit will not be started. Instead, new tasks will only begin once an ongoing task is completed, making room for the next one. When selecting the next task to execute, the system follows a prioritization strategy:
# If multiple tasks are available, the task from the oldest process (i.e., the one with the earliest processing date and smallest iteration code) is chosen.
# If there is only one process or multiple processes have the same processing date and iteration code, the task with the lowest numerical Priority value is selected.
# If multiple tasks share the same Priority value, the task with the highest Load value is executed next.
# If multiple tasks have the same Priority and Load values, the task with the lowest identifier (i.e., the oldest created task) is selected.

By following these rules, the system ensures efficient task execution while maintaining optimal server performance.
== Priority Inheritance ==

In typical processing, tasks that produce outputs for reporting or user interactions are often assigned higher priority. However, these tasks can only be executed after all dependent tasks are completed. Since multiple dependent tasks may exist, and they may be processed in a cascading manner, simply assigning a high priority to the final task is insufficient unless all preceding dependent tasks also have an appropriately elevated priority.

To address this, priority inheritance is implemented. This means that a task inherits the priority of any dependent task if that priority is higher (i.e., has a lower numerical value) than its own.
Example:
* Task A has a priority of 20.
* Task B has a priority of 10 and depends on Task A.
* Since Task B has a higher priority, Task A’s effective priority is also 10.

This priority inheritance applies only at the task level. If a group dependency is defined, tasks within the group do not inherit the priority of any dependent groups.

By implementing priority inheritance, the system ensures that critical reporting-related tasks are processed efficiently without unnecessary delays caused by lower-priority dependencies.

@@ Line 13: / Line 13: @@
 By following these rules, the system ensures efficient task execution while maintaining optimal server performance.
 == Priority Inheritance ==
-[[File:prio_inherit.png|right|Dedenie priorít]]
+[[File:Prio inherit.png|right|Dedenie priorít]]
 In typical processing, tasks that produce outputs for reporting or user interactions are often assigned higher priority. However, these tasks can only be executed after all dependent tasks are completed. Since multiple dependent tasks may exist, and they may be processed in a cascading manner, simply assigning a high priority to the final task is insufficient unless all preceding dependent tasks also have an appropriately elevated priority.