sched-rt-group.rst 6.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185
  1. ==========================
  2. Real-Time group scheduling
  3. ==========================
  4. .. CONTENTS
  5. 0. WARNING
  6. 1. Overview
  7. 1.1 The problem
  8. 1.2 The solution
  9. 2. The interface
  10. 2.1 System-wide settings
  11. 2.2 Default behaviour
  12. 2.3 Basis for grouping tasks
  13. 3. Future plans
  14. 0. WARNING
  15. ==========
  16. Fiddling with these settings can result in an unstable system, the knobs are
  17. root only and assumes root knows what he is doing.
  18. Most notable:
  19. * very small values in sched_rt_period_us can result in an unstable
  20. system when the period is smaller than either the available hrtimer
  21. resolution, or the time it takes to handle the budget refresh itself.
  22. * very small values in sched_rt_runtime_us can result in an unstable
  23. system when the runtime is so small the system has difficulty making
  24. forward progress (NOTE: the migration thread and kstopmachine both
  25. are real-time processes).
  26. 1. Overview
  27. ===========
  28. 1.1 The problem
  29. ---------------
  30. Realtime scheduling is all about determinism, a group has to be able to rely on
  31. the amount of bandwidth (eg. CPU time) being constant. In order to schedule
  32. multiple groups of realtime tasks, each group must be assigned a fixed portion
  33. of the CPU time available. Without a minimum guarantee a realtime group can
  34. obviously fall short. A fuzzy upper limit is of no use since it cannot be
  35. relied upon. Which leaves us with just the single fixed portion.
  36. 1.2 The solution
  37. ----------------
  38. CPU time is divided by means of specifying how much time can be spent running
  39. in a given period. We allocate this "run time" for each realtime group which
  40. the other realtime groups will not be permitted to use.
  41. Any time not allocated to a realtime group will be used to run normal priority
  42. tasks (SCHED_OTHER). Any allocated run time not used will also be picked up by
  43. SCHED_OTHER.
  44. Let's consider an example: a frame fixed realtime renderer must deliver 25
  45. frames a second, which yields a period of 0.04s per frame. Now say it will also
  46. have to play some music and respond to input, leaving it with around 80% CPU
  47. time dedicated for the graphics. We can then give this group a run time of 0.8
  48. * 0.04s = 0.032s.
  49. This way the graphics group will have a 0.04s period with a 0.032s run time
  50. limit. Now if the audio thread needs to refill the DMA buffer every 0.005s, but
  51. needs only about 3% CPU time to do so, it can do with a 0.03 * 0.005s =
  52. 0.00015s. So this group can be scheduled with a period of 0.005s and a run time
  53. of 0.00015s.
  54. The remaining CPU time will be used for user input and other tasks. Because
  55. realtime tasks have explicitly allocated the CPU time they need to perform
  56. their tasks, buffer underruns in the graphics or audio can be eliminated.
  57. NOTE: the above example is not fully implemented yet. We still
  58. lack an EDF scheduler to make non-uniform periods usable.
  59. 2. The Interface
  60. ================
  61. 2.1 System wide settings
  62. ------------------------
  63. The system wide settings are configured under the /proc virtual file system:
  64. /proc/sys/kernel/sched_rt_period_us:
  65. The scheduling period that is equivalent to 100% CPU bandwidth
  66. /proc/sys/kernel/sched_rt_runtime_us:
  67. A global limit on how much time realtime scheduling may use. Even without
  68. CONFIG_RT_GROUP_SCHED enabled, this will limit time reserved to realtime
  69. processes. With CONFIG_RT_GROUP_SCHED it signifies the total bandwidth
  70. available to all realtime groups.
  71. * Time is specified in us because the interface is s32. This gives an
  72. operating range from 1us to about 35 minutes.
  73. * sched_rt_period_us takes values from 1 to INT_MAX.
  74. * sched_rt_runtime_us takes values from -1 to (INT_MAX - 1).
  75. * A run time of -1 specifies runtime == period, ie. no limit.
  76. 2.2 Default behaviour
  77. ---------------------
  78. The default values for sched_rt_period_us (1000000 or 1s) and
  79. sched_rt_runtime_us (950000 or 0.95s). This gives 0.05s to be used by
  80. SCHED_OTHER (non-RT tasks). These defaults were chosen so that a run-away
  81. realtime tasks will not lock up the machine but leave a little time to recover
  82. it. By setting runtime to -1 you'd get the old behaviour back.
  83. By default all bandwidth is assigned to the root group and new groups get the
  84. period from /proc/sys/kernel/sched_rt_period_us and a run time of 0. If you
  85. want to assign bandwidth to another group, reduce the root group's bandwidth
  86. and assign some or all of the difference to another group.
  87. Realtime group scheduling means you have to assign a portion of total CPU
  88. bandwidth to the group before it will accept realtime tasks. Therefore you will
  89. not be able to run realtime tasks as any user other than root until you have
  90. done that, even if the user has the rights to run processes with realtime
  91. priority!
  92. 2.3 Basis for grouping tasks
  93. ----------------------------
  94. Enabling CONFIG_RT_GROUP_SCHED lets you explicitly allocate real
  95. CPU bandwidth to task groups.
  96. This uses the cgroup virtual file system and "<cgroup>/cpu.rt_runtime_us"
  97. to control the CPU time reserved for each control group.
  98. For more information on working with control groups, you should read
  99. Documentation/admin-guide/cgroup-v1/cgroups.rst as well.
  100. Group settings are checked against the following limits in order to keep the
  101. configuration schedulable:
  102. \Sum_{i} runtime_{i} / global_period <= global_runtime / global_period
  103. For now, this can be simplified to just the following (but see Future plans):
  104. \Sum_{i} runtime_{i} <= global_runtime
  105. 3. Future plans
  106. ===============
  107. There is work in progress to make the scheduling period for each group
  108. ("<cgroup>/cpu.rt_period_us") configurable as well.
  109. The constraint on the period is that a subgroup must have a smaller or
  110. equal period to its parent. But realistically its not very useful _yet_
  111. as its prone to starvation without deadline scheduling.
  112. Consider two sibling groups A and B; both have 50% bandwidth, but A's
  113. period is twice the length of B's.
  114. * group A: period=100000us, runtime=50000us
  115. - this runs for 0.05s once every 0.1s
  116. * group B: period= 50000us, runtime=25000us
  117. - this runs for 0.025s twice every 0.1s (or once every 0.05 sec).
  118. This means that currently a while (1) loop in A will run for the full period of
  119. B and can starve B's tasks (assuming they are of lower priority) for a whole
  120. period.
  121. The next project will be SCHED_EDF (Earliest Deadline First scheduling) to bring
  122. full deadline scheduling to the linux kernel. Deadline scheduling the above
  123. groups and treating end of the period as a deadline will ensure that they both
  124. get their allocated time.
  125. Implementing SCHED_EDF might take a while to complete. Priority Inheritance is
  126. the biggest challenge as the current linux PI infrastructure is geared towards
  127. the limited static priority levels 0-99. With deadline scheduling you need to
  128. do deadline inheritance (since priority is inversely proportional to the
  129. deadline delta (deadline - now)).
  130. This means the whole PI machinery will have to be reworked - and that is one of
  131. the most complex pieces of code we have.