Define classes for mutex and condition objects.

[loba.git] / communicator.cpp

diff --git a/communicator.cpp b/communicator.cpp
index 96cd598fbaf807574f8870952a9e05c352f1784f..506f126ce14b37975b4e61dfee62302a1b89f4be 100644 (file)
--- a/communicator.cpp
+++ b/communicator.cpp
@@ -25,16 +25,13 @@ std::string message::to_string()
 
 communicator::communicator()
     : host(static_cast<hostdata*>(MSG_host_get_data(MSG_host_self())))
 
 communicator::communicator()
     : host(static_cast<hostdata*>(MSG_host_get_data(MSG_host_self())))

-    , receiver_mutex(xbt_mutex_init())
-    , receiver_cond(xbt_cond_init())

 {
 {

-    xbt_mutex_acquire(receiver_mutex);
+    receiver_mutex.acquire();

     receiver_thread =
         MSG_process_create("receiver", communicator::receiver_wrapper,
                            this, MSG_host_self());
     receiver_thread =
         MSG_process_create("receiver", communicator::receiver_wrapper,
                            this, MSG_host_self());

-    // wait for the receiver to be ready
-    xbt_cond_wait(receiver_cond, receiver_mutex);
-    xbt_mutex_release(receiver_mutex);
+    receiver_cond.wait(receiver_mutex); // wait for the receiver to be ready
+    receiver_mutex.release();

 }
 
 communicator::~communicator()
 }
 
 communicator::~communicator()


@@ -49,12 +46,12 @@ communicator::~communicator()
     task = MSG_task_create("finalize", 0.0, 0, NULL);
     MSG_task_send(task, host->get_data_mbox());
 
     task = MSG_task_create("finalize", 0.0, 0, NULL);
     MSG_task_send(task, host->get_data_mbox());
 

-    xbt_mutex_acquire(receiver_mutex);
+    receiver_mutex.acquire();

     while (receiver_thread) {
         XBT_DEBUG("waiting for receiver to terminate");
     while (receiver_thread) {
         XBT_DEBUG("waiting for receiver to terminate");

-        xbt_cond_wait(receiver_cond, receiver_mutex);
+        receiver_cond.wait(receiver_mutex);

     }
     }

-    xbt_mutex_release(receiver_mutex);
+    receiver_mutex.release();

 
     if (!received.empty())
         XBT_WARN("lost %zu received message%s!",
 
     if (!received.empty())
         XBT_WARN("lost %zu received message%s!",


@@ -62,9 +59,6 @@ communicator::~communicator()
     if (!sent_comm.empty())
         XBT_WARN("lost %zu sent message%s!",
                  sent_comm.size(), ESSE(sent_comm.size()));
     if (!sent_comm.empty())
         XBT_WARN("lost %zu sent message%s!",
                  sent_comm.size(), ESSE(sent_comm.size()));

-
-    xbt_cond_destroy(receiver_cond);
-    xbt_mutex_destroy(receiver_mutex);

 }
 
 void communicator::send(const char* dest, message* msg)
 }
 
 void communicator::send(const char* dest, message* msg)


@@ -86,16 +80,16 @@ bool communicator::recv(message*& msg, m_host_t& from, double timeout)
     if (timeout != 0) {
         volatile double deadline =
             timeout > 0 ? MSG_get_clock() + timeout : 0.0;
     if (timeout != 0) {
         volatile double deadline =
             timeout > 0 ? MSG_get_clock() + timeout : 0.0;

-        xbt_mutex_acquire(receiver_mutex);
+        receiver_mutex.acquire();

         while (received.empty() && (!deadline || deadline > MSG_get_clock())) {
             xbt_ex_t e;
             XBT_DEBUG("waiting for a message to come");
             TRY {
                 if (deadline)
         while (received.empty() && (!deadline || deadline > MSG_get_clock())) {
             xbt_ex_t e;
             XBT_DEBUG("waiting for a message to come");
             TRY {
                 if (deadline)

-                    xbt_cond_timedwait(receiver_cond, receiver_mutex,
-                                       deadline - MSG_get_clock());
+                    receiver_cond.timedwait(receiver_mutex,
+                                            deadline - MSG_get_clock());

                 else
                 else

-                    xbt_cond_wait(receiver_cond, receiver_mutex);
+                    receiver_cond.wait(receiver_mutex);

             }
             CATCH (e) {
                 if (e.category != timeout_error)
             }
             CATCH (e) {
                 if (e.category != timeout_error)


@@ -103,7 +97,7 @@ bool communicator::recv(message*& msg, m_host_t& from, double timeout)
                 xbt_ex_free(e);
             }
         }
                 xbt_ex_free(e);
             }
         }

-        xbt_mutex_release(receiver_mutex);
+        receiver_mutex.release();

     }
 
     if (received.empty())
     }
 
     if (received.empty())


@@ -142,10 +136,10 @@ int communicator::receiver_wrapper(int, char* [])
     comm->receiver();
 
     XBT_DEBUG("terminate");
     comm->receiver();
 
     XBT_DEBUG("terminate");

-    xbt_mutex_acquire(comm->receiver_mutex);
+    comm->receiver_mutex.acquire();

     comm->receiver_thread = NULL;
     comm->receiver_thread = NULL;

-    xbt_cond_signal(comm->receiver_cond);
-    xbt_mutex_release(comm->receiver_mutex);
+    comm->receiver_cond.signal();
+    comm->receiver_mutex.release();

 
     return 0;
 }
 
     return 0;
 }


@@ -168,9 +162,9 @@ void communicator::receiver()
     }
 
     XBT_DEBUG("receiver ready");
     }
 
     XBT_DEBUG("receiver ready");

-    xbt_mutex_acquire(receiver_mutex);
-    xbt_cond_signal(receiver_cond); // signal master that we are ready
-    xbt_mutex_release(receiver_mutex);
+    receiver_mutex.acquire();
+    receiver_cond.signal();     // signal master that we are ready
+    receiver_mutex.release();

 
     while (!xbt_dynar_is_empty(comms)) {
 
 
     while (!xbt_dynar_is_empty(comms)) {
 


@@ -184,10 +178,10 @@ void communicator::receiver()
         comm_check_n_destroy(ch->comm);
         if (strcmp(MSG_task_get_name(ch->task), "finalize")) {
             XBT_DEBUG("received message on %s", ch->mbox);
         comm_check_n_destroy(ch->comm);
         if (strcmp(MSG_task_get_name(ch->task), "finalize")) {
             XBT_DEBUG("received message on %s", ch->mbox);

-            xbt_mutex_acquire(receiver_mutex);
+            receiver_mutex.acquire();

             received.push(ch->task);
             received.push(ch->task);

-            xbt_cond_signal(receiver_cond);
-            xbt_mutex_release(receiver_mutex);
+            receiver_cond.signal();
+            receiver_mutex.release();

             ch->task = NULL;
             ch->comm = MSG_task_irecv(&ch->task, ch->mbox);
             xbt_dynar_set_as(comms, index, msg_comm_t, ch->comm);
             ch->task = NULL;
             ch->comm = MSG_task_irecv(&ch->task, ch->mbox);
             xbt_dynar_set_as(comms, index, msg_comm_t, ch->comm);