Cleanup, no functional change (no bug fixed too).

diff --git a/process.cpp b/process.cpp
index 214b9d05a785d80edeb436f14466a6d8140545d9..a24d6ebcbfb5eae01f098611a3373a00f06a872f 100644 (file)
--- a/process.cpp
+++ b/process.cpp
@@ -32,6 +32,7 @@ process::process(int argc, char* argv[])
         rev_neigh.insert(std::make_pair(host, ptr));
     }
 
         rev_neigh.insert(std::make_pair(host, ptr));
     }
 

+    prev_load_broadcast = -1;   // force sending of load on first send()

     expected_load = load;
     total_load_init += load;
 
     expected_load = load;
     total_load_init += load;
 


@@ -40,7 +41,10 @@ process::process(int argc, char* argv[])
         comm.next_close_on_ctrl_is_last();
         comm.next_close_on_data_is_last();
     }
         comm.next_close_on_ctrl_is_last();
         comm.next_close_on_data_is_last();
     }

-    if (neigh.size() > 0)
+    close_received = false;
+    may_receive =  (neigh.size() > 0); // the same as (ctrl_close_pending ||
+                                       //              data_close_pending)
+    if (may_receive)

         comm.listen();
 
     e_xbt_log_priority_t logp = xbt_log_priority_verbose;
         comm.listen();
 
     e_xbt_log_priority_t logp = xbt_log_priority_verbose;


@@ -68,8 +72,6 @@ int process::run()
 {
     INFO1("Initial load: %g", load);
     VERB0("Starting...");
 {
     INFO1("Initial load: %g", load);
     VERB0("Starting...");

-    // first send() to inform neighbors about our load (force it)
-    prev_load_broadcast = -1;

     iter = 0;
     bool one_more = true;
     do {
     iter = 0;
     bool one_more = true;
     do {


@@ -95,24 +97,25 @@ int process::run()
 
 // NDS for Need To Send
 #define NDS ((opt::bookkeeping ? expected_load : load) != prev_load_broadcast)
 
 // NDS for Need To Send
 #define NDS ((opt::bookkeeping ? expected_load : load) != prev_load_broadcast)

-        bool can_recv;

         do {
         do {

-            // General idea: do not iterate if there is nothing to
-            // compute, nor to send.
+            // General idea: block on receiving unless there is
+            // something to compute, or to send, or we must exit.

 
             // fixme: review this chunk, and remove this NDS macro!
 
 
             // fixme: review this chunk, and remove this NDS macro!
 

+            // FIXME: HAD A DEADLOCK HERE...
+

             bool recv_wait = (load == 0 && !NDS);
             bool recv_wait = (load == 0 && !NDS);

-            bool close_received = !receive(recv_wait? WAIT: NO_WAIT);
+            DEBUG1("CALL RECEIVE(%s)", recv_wait? "WAIT": "NO_WAIT");
+            receive(recv_wait? WAIT: NO_WAIT);

 
             if (opt::exit_on_close && close_received)
                 one_more = false;
             else if (opt::maxiter && iter >= opt::maxiter)
                 one_more = false;
             
 
             if (opt::exit_on_close && close_received)
                 one_more = false;
             else if (opt::maxiter && iter >= opt::maxiter)
                 one_more = false;
             

-            can_recv = (ctrl_close_pending || data_close_pending);
-
-        } while (one_more && can_recv && load == 0 && !NDS);
+        } while (one_more && may_receive && load == 0 && !NDS);
+        DEBUG0("RECEIVE LOOP ENDED");

 #undef NDS
 
     } while (one_more);
 #undef NDS
 
     } while (one_more);


@@ -218,15 +221,14 @@ void process::send()
     }
 }
 
     }
 }
 

-bool process::receive(recv_wait_mode wait)
+void process::receive(recv_wait_mode wait)

 {
     // DEBUG1("go for receive(%s)",
     //        "NO_WAIT\0WAIT\0\0\0\0WAIT_FOR_CLOSE" + 8 * wait);
 {
     // DEBUG1("go for receive(%s)",
     //        "NO_WAIT\0WAIT\0\0\0\0WAIT_FOR_CLOSE" + 8 * wait);

-    bool result = true;

     message* msg;
     m_host_t from;
     message* msg;
     m_host_t from;

-    bool do_recv = ctrl_close_pending || data_close_pending;
-    while (do_recv && comm.recv(msg, from, wait)) {
+    bool do_loop = may_receive;
+    while (do_loop && comm.recv(msg, from, wait)) {

         switch (msg->get_type()) {
         case message::INFO: {
             neighbor* n = rev_neigh[from];
         switch (msg->get_type()) {
         case message::INFO: {
             neighbor* n = rev_neigh[from];


@@ -242,21 +244,20 @@ bool process::receive(recv_wait_mode wait)
         case message::CTRL_CLOSE:
             if (--ctrl_close_pending == 1)
                 comm.next_close_on_ctrl_is_last();
         case message::CTRL_CLOSE:
             if (--ctrl_close_pending == 1)
                 comm.next_close_on_ctrl_is_last();

-            DEBUG1("ctrl_close_pending = %d", ctrl_close_pending);
-            result = false;
+            // DEBUG1("ctrl_close_pending = %d", ctrl_close_pending);
+            close_received = true;

             break;
         case message::DATA_CLOSE:
             if (--data_close_pending == 1)
                 comm.next_close_on_data_is_last();
             break;
         case message::DATA_CLOSE:
             if (--data_close_pending == 1)
                 comm.next_close_on_data_is_last();

-            DEBUG1("data_close_pending = %d", data_close_pending);
-            result = false;
+            // DEBUG1("data_close_pending = %d", data_close_pending);
+            close_received = true;

             break;
         }
         delete msg;
             break;
         }
         delete msg;

-        do_recv = (wait == WAIT_FOR_CLOSE) &&
-            (ctrl_close_pending || data_close_pending);
+        may_receive = (ctrl_close_pending || data_close_pending);
+        do_loop = (wait == WAIT_FOR_CLOSE) && may_receive;

     }
     }

-    return result;

 }
 
 void process::finalize1(neighbor& nb)
 }
 
 void process::finalize1(neighbor& nb)

diff --git a/process.h b/process.h
index 68dcd9b71fecc45abc4dbc9f27c51b5e07348c34..c30b24374e0aed763bb626ed6d087350b1dbc548 100644 (file)
--- a/process.h
+++ b/process.h
@@ -61,6 +61,8 @@ private:
                                 // on ctrl channel
     int data_close_pending;     // number of "close" messages to wait
                                 // on data channel
                                 // on ctrl channel
     int data_close_pending;     // number of "close" messages to wait
                                 // on data channel

+    bool close_received;        // true if we received a "close" message
+    bool may_receive;           // true if there remains neighbors to listen for

 
     unsigned iter;              // counter of iterations
 
 
     unsigned iter;              // counter of iterations
 


@@ -84,10 +86,8 @@ private:
     void send();
 
     // Receive procedure: wait (or not) for a message to come.
     void send();
 
     // Receive procedure: wait (or not) for a message to come.

-    // Returns false if some "close" message was received, returns true
-    // otherwise.

     enum recv_wait_mode { NO_WAIT = 0, WAIT, WAIT_FOR_CLOSE };
     enum recv_wait_mode { NO_WAIT = 0, WAIT, WAIT_FOR_CLOSE };

-    bool receive(recv_wait_mode wait);
+    void receive(recv_wait_mode wait);

 
     // Finalize sends a "close" message to each neighbor and wait for
     // all of them to answer.
 
     // Finalize sends a "close" message to each neighbor and wait for
     // all of them to answer.