Changeset 8:dba41f33ddce in xplcommon

Timestamp:

12/29/12 08:01:50 (12 years ago)

Author:

István Váradi <ivaradi@…>

Branch:

default

Phase:

public

Message:

Clarified the blocking and non-blocking behaviour and extended the test program to test both

Files:

• src/xplcommon/WaitableEvent.h (modified) (1 diff)
• src/xplcommon/posix/WaitableEvent.cc (modified) (4 diffs)
• src/xplcommon/posix/WaitableEvent.h (modified) (3 diffs)
• test/testevent.cc (modified) (3 diffs)

src/xplcommon/WaitableEvent.h

@@ -44 +44 @@
  * An event on which one can wait with a waiter.
  */
-class WaitableEvent : public Waitable
+class WaitableEvent : public Waitable, public Failable
 {
 public:
     /**
      * Construct the event.
+     *
+     * @param waiter the waiter to be used for waiting. If given, the
+     * check() function will always return immediately. If not given,
+     * the check() function may block and returns only when the event
+     * is fired.
      */
     WaitableEvent(Waiter* waiter = 0);

src/xplcommon/posix/WaitableEvent.cc

@@ -48 +48 @@
 
 WaitableEvent::WaitableEvent(Waiter* waiter) :
-    Waitable(waiter, eventfd(0, EFD_NONBLOCK), POLLIN)
+    Waitable(waiter, eventfd(0, (waiter==0) ? 0 : EFD_NONBLOCK), POLLIN),
+    fired(false)
 {
     assert(fd>=0);
@@ -67 +68 @@
     if (write(fd, &one, sizeof(one))<0) {
         if (errno!=EAGAIN) {
-            perror("xplcommon::posix::WaitableEvent::fire: write");
-            assert(0);
+            setErrorCode(errno);
         }
     }
@@ -77 +77 @@
 bool WaitableEvent::check()
 {
-    if (fired) {
+    if (doCheck()) {
         fired = false;
         return true;
@@ -97 +97 @@
 {
     if ((events&POLLIN)==POLLIN) {
-        uint64_t value = 0;
-        if (read(fd, &value, sizeof(value))<0) {
-            if (errno!=EAGAIN) {
-                perror("xplcommon::posix::WaitableEvent::handleEvents: read");
-                assert(0);
-            }
-        } else {
-            fired = value>0;
+        doCheck();
+    }
+}
+
+//------------------------------------------------------------------------------
+
+bool WaitableEvent::doCheck(bool fromHandleEvents)
+{
+    if (failed()) return false;
+    if (!fromHandleEvents && fired) return true;
+
+    uint64_t value = 0;
+    if (read(fd, &value, sizeof(value))<0) {
+        if (errno!=EAGAIN) {
+            setErrorCode(errno);
         }
+    } else {
+        fired = fired || value>0;
     }
+
+    return fired;
 }
 

src/xplcommon/posix/WaitableEvent.h

@@ -34 +34 @@
 #include "Waitable.h"
 
+#include "../Failable.h"
+
 //------------------------------------------------------------------------------
 
@@ -43 +45 @@
  * An event on which one can wait with a waiter.
  */
-class WaitableEvent : public Waitable
+class WaitableEvent : public Waitable, public Failable
 {
 private:
@@ -83 +85 @@
      */
     virtual void handleEvents(short events);
+
+private:
+    /**
+     * Perform the real check. If we already know that we are fired,
+     * just return true. Otherwise try to read from the event fd.
+     */
+    bool doCheck(bool fromHandleEvents = false);
 };
 

test/testevent.cc

@@ -89 +89 @@
 //------------------------------------------------------------------------------
 
+class BlockingServerThread : public Thread
+{
+private:
+    WaitableEvent event;
+
+public:
+    WaitableEvent& getEvent();
+
+    virtual void run();
+};
+
+//------------------------------------------------------------------------------
+
+inline WaitableEvent& BlockingServerThread::getEvent()
+{
+    return event;
+}
+
+//------------------------------------------------------------------------------
+
+void BlockingServerThread::run()
+{
+    printf("BlockingServerThread::run: waiting...\n");
+    if (event.check()) {
+        printf("BlockingServerThread::run: waiting done\n");
+    } else {
+        printf("BlockingServerThread::run: waiting failed\n");
+    }
+    printf("BlockingServerThread::run: finished\n");
+}
+
+
+//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+
 class ClientThread : public Thread
 {
@@ -120 +155 @@
 //------------------------------------------------------------------------------
 
-int main()
+template <class Server> void runTest()
 {
-    ServerThread serverThread;
+    Server serverThread;
     ClientThread clientThread(serverThread.getEvent());
 
@@ -134 +169 @@
     serverThread.join();
     printf("Both threads returned\n");
+}
+
+//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+
+int main()
+{
+    printf("Running the event test with a non-blocking WaitableEvent\n\n");
+    runTest<ServerThread>();
+
+    printf("\n\nRunning the event test with a blocking WaitableEvent\n\n");
+    runTest<BlockingServerThread>();
 
     return 0;