[complement-svn] SF.net SVN: complement: [1582] trunk/complement/explore/test/virtual_time

[<com...@us...>]

Revision: 1582
          http://svn.sourceforge.net/complement/?rev=1582&view=rev
Author:   complement
Date:     2007-06-06 09:23:28 -0700 (Wed, 06 Jun 2007)

Log Message:
-----------
oh, first working

Modified Paths:
--------------
    trunk/complement/explore/test/virtual_time/vtime.cc
    trunk/complement/explore/test/virtual_time/vtime.h
    trunk/complement/explore/test/virtual_time/vtime_main.cc

Modified: trunk/complement/explore/test/virtual_time/vtime.cc
===================================================================
--- trunk/complement/explore/test/virtual_time/vtime.cc	2007-06-05 16:20:15 UTC (rev 1581)
+++ trunk/complement/explore/test/virtual_time/vtime.cc	2007-06-06 16:23:28 UTC (rev 1582)
@@ -133,39 +133,20 @@
 
 bool operator <=( const vtime_type& l, const vtime_type& r )
 {
-  if ( r.empty() ) {
-    return l.empty();
-  }
-
   if ( l.empty() ) {
     return true;
   }
 
-  vtime_type::const_iterator i = l.begin();
-  vtime_type::const_iterator j = r.begin();
-
-  while ( i != l.end() && j != r.end() ) {
-    if ( i->first < j->first ) { // v <= 0 --- false
-      return false;
-    }
-    while ( j != r.end() && i->first > j->first ) { // 0 <= v --- true
-      ++j;
-    }
-  
-    while ( i != l.end() && j != r.end() && i->first == j->first ) {
-      if ( i->second > j->second ) {
+  for ( vtime_type::const_iterator i = l.begin(); i != l.end(); ++i ) {
+    if ( i->second > 0 ) {
+      vtime_type::const_iterator j = r.find( i->first );
+      if ( j == r.end() || i->second > j->second ) {
 	return false;
       }
-      ++i;
-      ++j;
     }
   }
 
-  if ( i == l.end() ) {
-    return true;
-  }
-
-  return false;
+  return true;
 }
 
 vtime_type operator -( const vtime_type& l, const vtime_type& r )
@@ -173,11 +154,13 @@
   vtime_type tmp( r.begin(), r.end() );
 
   for ( vtime_type::iterator i = tmp.begin(); i != tmp.end(); ++i ) {
-    vtime_type::const_iterator p = l.find(i->first);
-    if ( p == l.end() || p->second < i->second ) {
-      throw range_error( "vtime different: right value grater then left" );
+    if ( i->second > 0 ) {
+      vtime_type::const_iterator p = l.find(i->first);
+      if ( p == l.end() || p->second < i->second ) {
+	throw range_error( "vtime different: right value grater then left" );
+      }
+      i->second = p->second - i->second;
     }
-    i->second = p->second - i->second;
   }
 
   for ( vtime_type::const_iterator i = l.begin(); i != l.end(); ++i ) {
@@ -221,6 +204,17 @@
   return tmp;
 }
 
+// template <>
+vtime max( const vtime& l, const vtime& r )
+{
+  vtime tmp( l );
+
+  for ( vtime_type::const_iterator i = r.vt.begin(); i != r.vt.end(); ++i ) {
+    tmp[i->first] = std::max( tmp[i->first], i->second );
+  }
+  return tmp;
+}
+
 vtime& vtime::operator +=( const vtime_type::value_type& t )
 {
   vt[t.first] += t.second;
@@ -235,6 +229,38 @@
   return gvt;
 }
 
+gvtime_type& operator +=( gvtime_type& l, const gvtime_type& r )
+{
+  for ( gvtime_type::const_iterator g = r.begin(); g != r.end(); ++g ) {
+    l[g->first] += g->second;
+  }
+
+  return l;
+}
+
+gvtime_type operator -( const gvtime_type& l, const gvtime_type& r )
+{
+  gvtime_type tmp( r );
+
+  for ( gvtime_type::iterator g = tmp.begin(); g != tmp.end(); ++g ) {
+    gvtime_type::const_iterator i = l.find( g->first );
+    if ( i == l.end() ) {
+      throw range_error( "gvtime different: right value grater then left" );
+    }
+
+    g->second = i->second - g->second;
+  }
+
+  for ( gvtime_type::const_iterator g = l.begin(); g != l.end(); ++g ) {
+    gvtime_type::const_iterator i = tmp.find(g->first);
+    if ( i == tmp.end() ) {
+      tmp[g->first] = g->second;
+    }
+  }
+
+  return tmp;
+}
+
 gvtime& gvtime::operator +=( const gvtime_type::value_type& t )
 {
   gvt[t.first] += t.second;
@@ -242,51 +268,98 @@
   return *this;  
 }
 
+gvtime& gvtime::operator +=( const gvtime& t )
+{
+  for ( gvtime_type::const_iterator g = t.gvt.begin(); g != t.gvt.end(); ++g ) {
+    gvt[g->first] += g->second;
+  }
+
+  return *this;
+}
+
 void Proc::mess( const stem::Event_base<VTmess>& ev )
 {
   cout << self_id() << " " << ev.value().mess << endl;
 
-  cout << ev.value().gvt.gvt << endl;
+  // cout << ev.value().gvt.gvt << endl;
 
-  cout << order_correct( ev ) << endl;
-
-  // if ( order_correct( ev ) ) {
-  // 
-  // }
+  if ( order_correct( ev ) ) {
+    cout << "Order correct" << endl; 
+    lvt[ev.src()] += ev.value().gvt.gvt;
+    lvt[ev.src()][ev.value().grp][ev.src()] = vt.gvt[ev.value().grp][ev.src()] + 1;
+    vt.gvt[ev.value().grp] = vt::max( vt.gvt[ev.value().grp], lvt[ev.src()][ev.value().grp] );
+    cout << vt.gvt << endl;
+  } else {
+    cout << "Order not correct" << endl; 
+  }
 }
 
 bool Proc::order_correct( const stem::Event_base<VTmess>& ev )
 {
-  // 1.
-
   gvtime gvt( ev.value().gvt );
 
   if ( vt.gvt[ev.value().grp][ev.src()] + 1 != gvt[ev.value().grp][ev.src()] ) {
+    cerr << "1" << endl;
+    cerr << vt.gvt[ev.value().grp][ev.src()] << "\n"
+	 << gvt[ev.value().grp][ev.src()]
+	 << endl;
     return false;
   }
 
-  vtime xvt = lvt[ev.value().grp] + gvt[ev.value().grp];
+  vtime xvt = lvt[ev.src()][ev.value().grp] + gvt[ev.value().grp];
   xvt[ev.src()] = 0;
 
   if ( !(xvt <= vt[ev.value().grp]) ) {
+    cerr << "2" << endl;
+    cerr << xvt << "\n\n"
+	 << vt[ev.value().grp] << endl;
     return false;
   }
 
-  // change: iteration through all groups of this object (not the same as below)
   for ( groups_container_type::const_iterator l = groups.begin(); l != groups.end(); ++l ) {
     if ( *l != ev.value().grp ) {
-      xvt = lvt[*l] + gvt[*l];
+      xvt = lvt[ev.src()][*l] + gvt[*l];
       if ( !(xvt <= vt[*l]) ) {
+	cerr << "3" << endl;
+	cerr << "group " << *l << xvt << "\n\n"
+	     << vt[*l] << endl;
 	return false;
       }
     }
   }
 
-  // lvt += gvt; 
-
   return true;
 }
 
+void Proc::SendVC( group_type g, const std::string& mess )
+{
+  try {
+    stem::Event_base<VTmess> m( MESS );
+    m.value().mess = mess;
+    m.value().grp = g;
+
+    vtime_type& gr = vt[g].vt;
+
+    gr[self_id()] += 1;
+
+    for ( vtime_type::const_iterator p = gr.begin(); p != gr.end(); ++p ) {
+      if ( p->first != self_id() ) {
+	m.dest( p->first );
+
+	m.value().gvt.gvt = vt.gvt - lvt[p->first];
+	m.value().gvt.gvt[g][self_id()] = gr[self_id()];
+
+	lvt[p->first] = vt.gvt;
+
+	Send(m);
+      }
+    }
+  }
+  catch ( const range_error& err ) {
+    cerr << err.what() << endl;
+  }
+}
+
 DEFINE_RESPONSE_TABLE( Proc )
   EV_Event_base_T_( ST_NULL, MESS, mess, VTmess )
 END_RESPONSE_TABLE
@@ -304,21 +377,24 @@
 {
   o << "[\n";
   for ( vt::vtime_type::const_iterator i = v.begin(); i != v.end(); ++i ) {
-    o << *i;
+    o << "  " << *i;
   }
-  return o << "]\n";
+  return o << " ]\n";
 }
 
+ostream& operator <<( ostream& o, const vt::vtime& v )
+{ return o << v.vt; }
+
 ostream& operator <<( ostream& o, const vt::gvtime_type::value_type& v )
 {
-  o << v.first << ": " << v.second.vt;
+  o << "group " << v.first << ": " << v.second.vt;
 }
 
 ostream& operator <<( ostream& o, const vt::gvtime_type& v )
 {
   o << "{\n";
   for ( vt::gvtime_type::const_iterator i = v.begin(); i != v.end(); ++i ) {
-    o << *i;
+    o << " " << *i;
   }
   return o << "}\n";
 }

Modified: trunk/complement/explore/test/virtual_time/vtime.h
===================================================================
--- trunk/complement/explore/test/virtual_time/vtime.h	2007-06-05 16:20:15 UTC (rev 1581)
+++ trunk/complement/explore/test/virtual_time/vtime.h	2007-06-06 16:23:28 UTC (rev 1582)
@@ -84,11 +84,16 @@
   vtime_type vt;
 };
 
+
+vtime max( const vtime& l, const vtime& r );
+
 // typedef std::pair<group_type, vtime> vtime_group_type;
 // typedef std::list<vtime_group_type> gvtime_type;
 typedef std::hash_map<group_type, vtime> gvtime_type;
 
 gvtime_type& operator +=( gvtime_type&, const gvtime_type::value_type& );
+gvtime_type& operator +=( gvtime_type&, const gvtime_type& );
+gvtime_type operator -( const gvtime_type& l, const gvtime_type& r );
 
 struct gvtime :
     public stem::__pack_base
@@ -108,6 +113,7 @@
     { gvt = _gvt.gvt; }
 
   gvtime& operator +=( const gvtime_type::value_type& );
+  gvtime& operator +=( const gvtime& );
 
   gvtime_type::data_type& operator[]( const gvtime_type::key_type k )
     { return gvt[k]; }
@@ -149,6 +155,11 @@
     void add_group( group_type g )
       { groups.push_back( g ); }
 
+    void add_group_member( group_type g, oid_type p )
+      { vt[g][p]; }
+
+    void SendVC( group_type, const std::string& mess );
+
     void mess( const stem::Event_base<VTmess>& );
 
     typedef std::list<group_type> groups_container_type;
@@ -157,7 +168,9 @@
 
     bool order_correct( const stem::Event_base<VTmess>& );
 
-    gvtime lvt;
+    typedef std::hash_map<oid_type, gvtime_type> delta_vtime_type;
+
+    delta_vtime_type lvt;
     gvtime vt;
     groups_container_type groups;
 
@@ -173,6 +186,7 @@
 
 ostream& operator <<( ostream&, const vt::vtime_type::value_type& );
 ostream& operator <<( ostream&, const vt::vtime_type& );
+ostream& operator <<( ostream&, const vt::vtime& );
 ostream& operator <<( ostream&, const vt::gvtime_type::value_type& );
 ostream& operator <<( ostream&, const vt::gvtime_type& );
 

Modified: trunk/complement/explore/test/virtual_time/vtime_main.cc
===================================================================
--- trunk/complement/explore/test/virtual_time/vtime_main.cc	2007-06-05 16:20:15 UTC (rev 1581)
+++ trunk/complement/explore/test/virtual_time/vtime_main.cc	2007-06-06 16:23:28 UTC (rev 1582)
@@ -24,31 +24,33 @@
   m2.add_group( 0 );
   r1.add_group( 0 );
 
+  m1.add_group_member( 0, m2.self_id() );
+  m1.add_group_member( 0, r1.self_id() );
+
+  r1.add_group_member( 0, m1.self_id() );
+  r1.add_group_member( 0, m2.self_id() );
+
+  m2.add_group_member( 0, m1.self_id() );
+  m2.add_group_member( 0, r1.self_id() );
+
   m1.add_group( 1 );
   m2.add_group( 1 );
   r2.add_group( 1 );
 
-  stem::Event_base<VTmess> mess( MESS );
-  
-  mess.dest( m2.self_id() );
+  m1.add_group_member( 1, m2.self_id() );
+  m1.add_group_member( 1, r2.self_id() );
 
-  mess.value().mess = "Hello!";
-  mess.value().grp = 0;
-  mess.value().gvt.gvt[0][m1.self_id()] = 1;
+  r2.add_group_member( 1, m1.self_id() );
+  r2.add_group_member( 1, m2.self_id() );
 
-  m1.Send( mess );
+  m2.add_group_member( 1, m1.self_id() );
+  m2.add_group_member( 1, r2.self_id() );
 
-  mess.dest( r1.self_id() );
+  r1.SendVC( 0, "Hello!" );
 
-  m1.Send( mess );
+  m1.SendVC( 0, "How are you?" );
 
-  // mess.value().gvt.gvt[0][m1.self_id()] += 1;
-
-  // mess.value().mess = "How are you?";
-  // m1.Send( mess );
-
   cnd.wait();
 
   return 0;
 }
-


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.