Improve granularity of wait call in Inference class

It now accepts a timeout expressed in nanoseconds.

Change-Id: I77fb89c33dc117f846b86494883548ef3241f0ab

3 files changed, 26 insertions, 13 deletions

diff --git a/driver_library/include/ethosu.hpp b/driver_library/include/ethosu.hpp
index d70ec95..fe3dc83 100644
--- a/driver_library/include/ethosu.hpp
+++ b/driver_library/include/ethosu.hpp
@@ -214,7 +214,7 @@ public:
 
     virtual ~Inference();
 
-    int wait(int timeoutSec = -1);
+    int wait(int64_t timeoutNanos = -1);
     const std::vector<uint32_t> getPmuCounters();
     uint64_t getCycleCounter();
     bool failed();
diff --git a/driver_library/src/ethosu.cpp b/driver_library/src/ethosu.cpp
index 4457e3f..45e8525 100644
--- a/driver_library/src/ethosu.cpp
+++ b/driver_library/src/ethosu.cpp
@@ -27,6 +27,7 @@
 
 #include <fcntl.h>
 #include <poll.h>
+#include <signal.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <unistd.h>
@@ -52,10 +53,11 @@ __attribute__((weak)) int eopen(const char *pathname, int flags) {
     return fd;
 }
 
-__attribute__((weak)) int epoll(struct pollfd *fds, nfds_t nfds, int timeout) {
-    int result = ::poll(fds, nfds, timeout);
+__attribute__((weak)) int
+eppoll(struct pollfd *fds, nfds_t nfds, const struct timespec *tmo_p, const sigset_t *sigmask) {
+    int result = ::ppoll(fds, nfds, tmo_p, sigmask);
     if (result < 0) {
-        throw Exception("Failed to wait for poll event");
+        throw Exception("Failed to wait for ppoll event or signal");
     }
 
     return result;
@@ -391,18 +393,23 @@ uint32_t Inference::getMaxPmuEventCounters() {
     return ETHOSU_PMU_EVENT_MAX;
 }
 
-int Inference::wait(int timeoutSec) {
-    pollfd pfd;
-
+int Inference::wait(int64_t timeoutNanos) {
+    struct pollfd pfd;
     pfd.fd      = fd;
     pfd.events  = POLLIN | POLLERR;
     pfd.revents = 0;
 
-    int ret = epoll(&pfd, 1, timeoutSec * 1000);
+    // if timeout negative wait forever
+    if (timeoutNanos < 0) {
+        return eppoll(&pfd, 1, NULL, NULL);
+    }
 
-    cout << "Poll. ret=" << ret << ", revents=" << pfd.revents << endl;
+    struct timespec tmo_p;
+    int64_t nanosec = 1000000000;
+    tmo_p.tv_sec    = timeoutNanos / nanosec;
+    tmo_p.tv_nsec   = timeoutNanos % nanosec;
 
-    return ret;
+    return eppoll(&pfd, 1, &tmo_p, NULL);
 }
 
 bool Inference::failed() {
diff --git a/driver_library/src/ethosu_stub.cpp b/driver_library/src/ethosu_stub.cpp
index 510007f..428d276 100644
--- a/driver_library/src/ethosu_stub.cpp
+++ b/driver_library/src/ethosu_stub.cpp
@@ -76,9 +76,15 @@ int eioctl(int, unsigned long cmd, void *) {
     }
 }
 
-int epoll(struct pollfd *, nfds_t, int timeout_ms) {
-    int t = 1000 * timeout_ms / 2;
-    usleep(t);
+int eppoll(struct pollfd *, nfds_t, const struct timespec *tmo_p, const sigset_t *) {
+    if (tmo_p == NULL) {
+        // sleep one second
+        usleep(1000000ul);
+    } else {
+        unsigned long t = tmo_p->tv_sec / 2;   // sleep half of the time
+        t               = t * 1000ul * 1000ul; // sec to microsec
+        usleep(t);
+    }
     return 1;
 }
 } // namespace EthosU