Clean-ups and fixes to compile with more warnings enabled and with g++.

[invirt/third/libt4.git] / paxos.cc

diff --git a/paxos.cc b/paxos.cc
index f9d5785..4bba25d 100644 (file)
--- a/paxos.cc
+++ b/paxos.cc
@@ -1,13 +1,15 @@
 #include "paxos.h"
 #include "handle.h"
 
 #include "paxos.h"
 #include "handle.h"
 

+paxos_change::~paxos_change() {}
+

 bool isamember(const node_t & m, const nodes_t & nodes) {
     return find(nodes.begin(), nodes.end(), m) != nodes.end();
 }
 
 // check if l2 contains a majority of the elements of l1
 bool isamember(const node_t & m, const nodes_t & nodes) {
     return find(nodes.begin(), nodes.end(), m) != nodes.end();
 }
 
 // check if l2 contains a majority of the elements of l1

-bool majority(const nodes_t &l1, const nodes_t &l2) {
-    auto overlap = (size_t)count_if(l1.begin(), l1.end(), bind(isamember, _1, l2));
+bool majority(const nodes_t & l1, const nodes_t & l2) {
+    auto overlap = (size_t)count_if(l1.begin(), l1.end(), std::bind(isamember, _1, l2));

     return overlap >= (l1.size() >> 1) + 1;
 }
 
     return overlap >= (l1.size() >> 1) + 1;
 }
 

@@ -20,7 +22,7 @@ bool majority(const nodes_t &l1, const nodes_t &l2) {
 // paxos_commit to inform higher layers of the agreed value for this
 // instance.
 
 // paxos_commit to inform higher layers of the agreed value for this
 // instance.
 

-proposer_acceptor::proposer_acceptor(class paxos_change *_delegate,
+proposer_acceptor::proposer_acceptor(paxos_change *_delegate,

         bool _first, const node_t & _me, const value_t & _value)
     : delegate(_delegate), me (_me)
 {
         bool _first, const node_t & _me, const value_t & _value)
     : delegate(_delegate), me (_me)
 {

@@ -46,14 +48,17 @@ bool proposer_acceptor::run(unsigned instance, const nodes_t & cur_nodes, const
     }
     stable = false;
     bool r = false;
     }
     stable = false;
     bool r = false;

-    proposal.n = std::max(promise.n, proposal.n) + 1;
+    proposal.n = max(promise.n, proposal.n) + 1;

     nodes_t accepts;
     nodes_t accepts;

-    value_t v = newv;
+    value_t v;

     if (prepare(instance, accepts, cur_nodes, v)) {
 
         if (majority(cur_nodes, accepts)) {
             LOG("received a majority of prepare responses");
 
     if (prepare(instance, accepts, cur_nodes, v)) {
 
         if (majority(cur_nodes, accepts)) {
             LOG("received a majority of prepare responses");
 

+            if (!v.size())
+                v = newv;
+

             breakpoint1();
 
             nodes_t nodes;
             breakpoint1();
 
             nodes_t nodes;

@@ -91,7 +96,7 @@ bool proposer_acceptor::prepare(unsigned instance, nodes_t & accepts,
         if (!r)
             continue;
         auto status = (paxos_protocol::status)r->call_timeout(
         if (!r)
             continue;
         auto status = (paxos_protocol::status)r->call_timeout(

-                paxos_protocol::preparereq, rpcc::to(1000), res, me, instance, proposal);
+                paxos_protocol::preparereq, milliseconds(100), res, me, instance, proposal);

         if (status == paxos_protocol::OK) {
             if (res.oldinstance) {
                 LOG("commiting old instance!");
         if (status == paxos_protocol::OK) {
             if (res.oldinstance) {
                 LOG("commiting old instance!");

@@ -122,7 +127,7 @@ void proposer_acceptor::accept(unsigned instance, nodes_t & accepts,
             continue;
         bool accept = false;
         int status = r->call_timeout(
             continue;
         bool accept = false;
         int status = r->call_timeout(

-                paxos_protocol::acceptreq, rpcc::to(1000), accept, me, instance, proposal, v);
+                paxos_protocol::acceptreq, milliseconds(100), accept, me, instance, proposal, v);

         if (status == paxos_protocol::OK && accept)
             accepts.push_back(i);
     }
         if (status == paxos_protocol::OK && accept)
             accepts.push_back(i);
     }

@@ -135,7 +140,7 @@ void proposer_acceptor::decide(unsigned instance, const nodes_t & accepts, const
         if (!r)
             continue;
         int res = 0;
         if (!r)
             continue;
         int res = 0;

-        r->call_timeout(paxos_protocol::decidereq, rpcc::to(1000), res, me, instance, v);
+        r->call_timeout(paxos_protocol::decidereq, milliseconds(100), res, me, instance, v);

     }
 }
 
     }
 }
 

@@ -203,17 +208,18 @@ void proposer_acceptor::commit(unsigned instance, const value_t & value) {
 }
 
 void proposer_acceptor::commit(unsigned instance, const value_t & value, lock & pxs_mutex_lock) {
 }
 
 void proposer_acceptor::commit(unsigned instance, const value_t & value, lock & pxs_mutex_lock) {

-    LOG("acceptor::commit: instance=" << instance << " has v=" << value);
+    LOG("instance=" << instance << " has v=" << value);

     if (instance > instance_h) {
     if (instance > instance_h) {

-        LOG("commit: highestacceptedinstance = " << instance);
+        LOG("highestacceptedinstance = " << instance);

         values[instance] = value;
         l.loginstance(instance, value);
         instance_h = instance;
         accepted = promise = {0, me};
         values[instance] = value;
         l.loginstance(instance, value);
         instance_h = instance;
         accepted = promise = {0, me};

-        accepted_value.clear();
+        string v = value; // gaaahhh aliasing of value and accepted_value
+        accepted_value.clear(); // this wipes out "value", too

         if (delegate) {
             pxs_mutex_lock.unlock();
         if (delegate) {
             pxs_mutex_lock.unlock();

-            delegate->paxos_commit(instance, value);
+            delegate->paxos_commit(instance, v);

             pxs_mutex_lock.lock();
         }
     }
             pxs_mutex_lock.lock();
         }
     }

@@ -236,10 +242,10 @@ void proposer_acceptor::breakpoint2() {
 
 void proposer_acceptor::breakpoint(int b) {
     if (b == 3) {
 
 void proposer_acceptor::breakpoint(int b) {
     if (b == 3) {

-        LOG("Proposer: breakpoint 1");
+        LOG("breakpoint 1");

         break1 = true;
     } else if (b == 4) {
         break1 = true;
     } else if (b == 4) {

-        LOG("Proposer: breakpoint 2");
+        LOG("breakpoint 2");

         break2 = true;
     }
 }
         break2 = true;
     }
 }