Make sure we do flush out the previous spinner and delay signaling
transition completion until we do.

References: https://bugs.freedesktop.org/show_bug.cgi?id=102250
Signed-off-by: Chris Wilson <[email protected]>
Cc: Katarzyna Dec <[email protected]>
---
 tests/pm_rps.c | 26 +++++++++++++++++++++-----
 1 file changed, 21 insertions(+), 5 deletions(-)

diff --git a/tests/pm_rps.c b/tests/pm_rps.c
index 84e71fa8a..23b33f41b 100644
--- a/tests/pm_rps.c
+++ b/tests/pm_rps.c
@@ -218,6 +218,7 @@ static void load_helper_set_load(enum load load)
 
 static void load_helper_run(enum load load)
 {
+       bool dummy;
        int link[2];
 
        /*
@@ -233,13 +234,14 @@ static void load_helper_run(enum load load)
 
        lh.exit = false;
        lh.load = load;
-       lh.signal = false;
+       lh.signal = true;
 
        pipe(link);
        lh.link = link[1];
 
        igt_fork_helper(&lh.igt_proc) {
                igt_spin_t *spin[2] = {};
+               bool prev_load;
                uint32_t handle;
 
                signal(SIGUSR1, load_helper_signal_handler);
@@ -247,10 +249,14 @@ static void load_helper_run(enum load load)
 
                igt_debug("Applying %s load...\n", lh.load ? "high" : "low");
 
+               prev_load = lh.load == HIGH;
                spin[0] = __igt_spin_batch_new(drm_fd);
-               if (lh.load == HIGH)
+               if (prev_load)
                        spin[1] = __igt_spin_batch_new(drm_fd);
+               prev_load = !prev_load; /* send the initial signal */
                while (!lh.exit) {
+                       bool high_load;
+
                        handle = spin[0]->handle;
                        igt_spin_batch_end(spin[0]);
                        while (gem_bo_busy(drm_fd, handle))
@@ -259,13 +265,20 @@ static void load_helper_run(enum load load)
                        igt_spin_batch_free(drm_fd, spin[0]);
                        usleep(100);
 
-                       spin[0] = spin[1];
-                       spin[lh.load == HIGH] = __igt_spin_batch_new(drm_fd);
+                       high_load = lh.load == HIGH;
+                       if (!high_load && spin[1]) {
+                               igt_spin_batch_free(drm_fd, spin[1]);
+                               spin[1] = NULL;
+                       } else {
+                               spin[0] = spin[1];
+                       }
+                       spin[high_load] = __igt_spin_batch_new(drm_fd);
 
-                       if (lh.signal) {
+                       if (lh.signal && high_load != prev_load) {
                                write(lh.link, &lh.signal, sizeof(lh.signal));
                                lh.signal = false;
                        }
+                       prev_load = high_load;
                }
 
                handle = spin[0]->handle;
@@ -294,6 +307,9 @@ static void load_helper_run(enum load load)
 
        close(lh.link);
        lh.link = link[0];
+
+       /* wait for our helper to complete its first round */
+       igt_assert_eq(read(lh.link, &dummy, sizeof(dummy)), sizeof(dummy));
 }
 
 static void load_helper_stop(void)
-- 
2.19.0.rc1

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Reply via email to