Skip to content
Snippets Groups Projects
  • Nadav Har'El's avatar
    a8c2fea7
    Test for scheduler's single-CPU fairness. · a8c2fea7
    Nadav Har'El authored
    
    This patch adds tst-scheduler.cc, containing a few tests for the fairness
    of scheduling of several threads on one CPU (for scheduling issues involving
    load-balancing across multiple CPUs, check out the existing tst-loadbalance).
    
    The test is written in standard C++11, so it can be compiled and
    run on both Linux and OSv, to compare their scheduler behaviors.
    It is actually more a benchmark then a test (it doesn't "succeed" or "fail").
    
    The test begins with several tests of the long-term fairness of the
    schduler when threads of different or identical priorities are run for
    10 seconds, and we look at how much work each thread got done in those
    10 seconds. This test only works on OSv (which supports float priorities).
    
    The second part of the test again tests long-term fairness of the scheduler
    when all threads have the default priority (so this test is standard C++11):
    We run a loop which takes (when run alone) 10 seconds, on 2 or 3
    threads in parallel. We expect to see that all 2 or 3 threads
    finish at (more-or-less) exactly the same time - after 20 or 30
    seconds. Both OSv and Linux pass this test with flying colors.
    
    The third part of the test runs two different threads concurrently:
     1. One thread wants to use all available CPU to loop for 10 seconds.
     2. The second thread wants to loop in an amount that takes N
        milliseconds, and then sleep for N milliseconds, and so on,
        until completing the same number of loop iterations that (when run
        alone) takes 10 seconds.
    
    The "fair" behavior of the this test is that both threads get equal
    CPU time and finish together: Thread 2 runs for N milliseconds, then
    while it is sleeping for N more, Thread 1 gets to run.
    This measure this for N=1 through 32ms. In OSv's new scheduler, indeed both
    threads get an almost fair share (with N=32ms, one thread finishes in 19
    seconds, the second in 21.4 seconds; we don't expect total fairness because
    of the runtime decay).
    
    Signed-off-by: default avatarNadav Har'El <nyh@cloudius-systems.com>
    Signed-off-by: default avatarPekka Enberg <penberg@cloudius-systems.com>
    a8c2fea7
    History
    Test for scheduler's single-CPU fairness.
    Nadav Har'El authored
    
    This patch adds tst-scheduler.cc, containing a few tests for the fairness
    of scheduling of several threads on one CPU (for scheduling issues involving
    load-balancing across multiple CPUs, check out the existing tst-loadbalance).
    
    The test is written in standard C++11, so it can be compiled and
    run on both Linux and OSv, to compare their scheduler behaviors.
    It is actually more a benchmark then a test (it doesn't "succeed" or "fail").
    
    The test begins with several tests of the long-term fairness of the
    schduler when threads of different or identical priorities are run for
    10 seconds, and we look at how much work each thread got done in those
    10 seconds. This test only works on OSv (which supports float priorities).
    
    The second part of the test again tests long-term fairness of the scheduler
    when all threads have the default priority (so this test is standard C++11):
    We run a loop which takes (when run alone) 10 seconds, on 2 or 3
    threads in parallel. We expect to see that all 2 or 3 threads
    finish at (more-or-less) exactly the same time - after 20 or 30
    seconds. Both OSv and Linux pass this test with flying colors.
    
    The third part of the test runs two different threads concurrently:
     1. One thread wants to use all available CPU to loop for 10 seconds.
     2. The second thread wants to loop in an amount that takes N
        milliseconds, and then sleep for N milliseconds, and so on,
        until completing the same number of loop iterations that (when run
        alone) takes 10 seconds.
    
    The "fair" behavior of the this test is that both threads get equal
    CPU time and finish together: Thread 2 runs for N milliseconds, then
    while it is sleeping for N more, Thread 1 gets to run.
    This measure this for N=1 through 32ms. In OSv's new scheduler, indeed both
    threads get an almost fair share (with N=32ms, one thread finishes in 19
    seconds, the second in 21.4 seconds; we don't expect total fairness because
    of the runtime decay).
    
    Signed-off-by: default avatarNadav Har'El <nyh@cloudius-systems.com>
    Signed-off-by: default avatarPekka Enberg <penberg@cloudius-systems.com>