From 9c7cfc0df2ccbd0c5a99f4460ba5750b775623fc Mon Sep 17 00:00:00 2001
From: xinhui pan <xinhui.pan@amd.com>
Date: Mon, 27 Aug 2018 14:56:48 +0800
Subject: [PATCH] kfdtest: Add event-based synchronization mechanism to queues

Wait4PacketConsumption now can accept an event to wait all packets subbmitted
to be processed.

Change-Id: I1497b7704e892b04d05811b8d3e4742237c1be57
Signed-off-by: xinhui pan <xinhui.pan@amd.com>
---
 tests/kfdtest/src/BaseQueue.cpp |  3 ++-
 tests/kfdtest/src/BaseQueue.hpp |  2 +-
 tests/kfdtest/src/PM4Queue.cpp  | 12 ++++++++++++
 tests/kfdtest/src/PM4Queue.hpp  |  8 ++++++++
 tests/kfdtest/src/SDMAQueue.cpp | 12 ++++++++++++
 tests/kfdtest/src/SDMAQueue.hpp |  9 +++++++++
 6 files changed, 44 insertions(+), 2 deletions(-)

diff --git a/tests/kfdtest/src/BaseQueue.cpp b/tests/kfdtest/src/BaseQueue.cpp
index 50ca76f778..e8a65ff10a 100644
--- a/tests/kfdtest/src/BaseQueue.cpp
+++ b/tests/kfdtest/src/BaseQueue.cpp
@@ -116,7 +116,8 @@ void BaseQueue::PlaceAndSubmitPacket(const BasePacket &packet) {
     SubmitPacket();
 }
 
-void BaseQueue::Wait4PacketConsumption() {
+void BaseQueue::Wait4PacketConsumption(HsaEvent *event) {
+    ASSERT_TRUE(!event) << "Not supported!" << std::endl;
     ASSERT_TRUE(WaitOnValue(m_Resources.Queue_read_ptr, RptrWhenConsumed()));
 }
 
diff --git a/tests/kfdtest/src/BaseQueue.hpp b/tests/kfdtest/src/BaseQueue.hpp
index a45c44d8b9..ba0464a6e0 100644
--- a/tests/kfdtest/src/BaseQueue.hpp
+++ b/tests/kfdtest/src/BaseQueue.hpp
@@ -63,7 +63,7 @@ class BaseQueue {
     /** Wait for all the packets submitted to the queue to be consumed. (i.e. wait until RPTR=WPTR).
      *  Note that all packets being consumed is not the same as all packets being processed.
      */
-    virtual void Wait4PacketConsumption();
+    virtual void Wait4PacketConsumption(HsaEvent *event = NULL);
     /** @brief Place packet and submit it in one function
      */
     virtual void PlaceAndSubmitPacket(const BasePacket &packet);
diff --git a/tests/kfdtest/src/PM4Queue.cpp b/tests/kfdtest/src/PM4Queue.cpp
index d1152c0b34..99707fb9ad 100644
--- a/tests/kfdtest/src/PM4Queue.cpp
+++ b/tests/kfdtest/src/PM4Queue.cpp
@@ -71,3 +71,15 @@ void PM4Queue::SubmitPacket() {
     }
 }
 
+void PM4Queue::Wait4PacketConsumption(HsaEvent *event) {
+    if (event) {
+        PlaceAndSubmitPacket(PM4ReleaseMemoryPacket(0,
+                    event->EventData.HWData2,
+                    event->EventId,
+                    true));
+
+        EXPECT_SUCCESS(hsaKmtWaitOnEvent(event, g_TestTimeOut));
+    } else {
+        BaseQueue::Wait4PacketConsumption();
+    }
+}
diff --git a/tests/kfdtest/src/PM4Queue.hpp b/tests/kfdtest/src/PM4Queue.hpp
index dd5d35b85f..64e8f4ec96 100644
--- a/tests/kfdtest/src/PM4Queue.hpp
+++ b/tests/kfdtest/src/PM4Queue.hpp
@@ -41,6 +41,14 @@ class PM4Queue : public BaseQueue {
     virtual unsigned int Wptr();
     // @ return expected m_Resources.Queue_read_ptr when all packets consumed
     virtual unsigned int RptrWhenConsumed();
+    /** Wait for all the packets submitted to the queue to be consumed. (i.e. wait until RPTR=WPTR).
+     *  Note that all packets being consumed is not the same as all packets being processed.
+     *  If event is set, wait all packets being processed.
+     *  And we can benefit from that as it has
+     *  1) Less CPU usage (process can sleep, waiting for interrupt).
+     *  2) Lower latency (GPU only updates RPTR in memory periodically).
+     */
+    virtual void Wait4PacketConsumption(HsaEvent *event = NULL);
 
  protected:
     virtual PACKETTYPE PacketTypeSupported() { return PACKETTYPE_PM4; }
diff --git a/tests/kfdtest/src/SDMAQueue.cpp b/tests/kfdtest/src/SDMAQueue.cpp
index 6f352b2cef..047b9eae74 100644
--- a/tests/kfdtest/src/SDMAQueue.cpp
+++ b/tests/kfdtest/src/SDMAQueue.cpp
@@ -22,6 +22,7 @@
  */
 
 #include "SDMAQueue.hpp"
+#include "SDMAPacket.hpp"
 
 SDMAQueue::SDMAQueue(void) {
      CMD_NOP = 0;
@@ -79,3 +80,14 @@ void SDMAQueue::SubmitPacket() {
     }
 }
 
+void SDMAQueue::Wait4PacketConsumption(HsaEvent *event) {
+    if (event) {
+        PlacePacket(SDMAFencePacket((void*)event->EventData.HWData2, event->EventId));
+
+        PlaceAndSubmitPacket(SDMATrapPacket(event->EventId));
+
+        EXPECT_SUCCESS(hsaKmtWaitOnEvent(event, g_TestTimeOut));
+    } else {
+        BaseQueue::Wait4PacketConsumption();
+    }
+}
diff --git a/tests/kfdtest/src/SDMAQueue.hpp b/tests/kfdtest/src/SDMAQueue.hpp
index fa762e3742..75a0f2a250 100644
--- a/tests/kfdtest/src/SDMAQueue.hpp
+++ b/tests/kfdtest/src/SDMAQueue.hpp
@@ -34,6 +34,15 @@ class SDMAQueue : public BaseQueue {
     // @brief Update queue write pointer and set the queue doorbell to the queue write pointer
     virtual void SubmitPacket();
 
+    /** Wait for all the packets submitted to the queue to be consumed. (i.e. wait until RPTR=WPTR).
+     *  Note that all packets being consumed is not the same as all packets being processed.
+     *  If event is set, wait all packets being processed.
+     *  And we can benefit from that as it has
+     *  1) Less CPU usage (process can sleep, waiting for interrupt).
+     *  2) Lower latency (GPU only updates RPTR in memory periodically).
+     */
+    virtual void Wait4PacketConsumption(HsaEvent *event = NULL);
+
  protected:
     // @ return Write pointer modulo queue size in dwords
     virtual unsigned int Wptr();