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

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 1569
          http://svn.sourceforge.net/complement/?rev=1569&view=rev
Author:   complement
Date:     2007-05-23 08:26:04 -0700 (Wed, 23 May 2007)

Log Message:
-----------
development

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-05-22 15:05:03 UTC (rev 1568)
+++ trunk/complement/explore/test/virtual_time/vtime.cc	2007-05-23 15:26:04 UTC (rev 1569)
@@ -104,24 +104,28 @@
 void VTmess::pack( std::ostream& s ) const
 {
   gvt.pack( s );
+  __pack( s, grp );
   __pack( s, mess );
 }
 
 void VTmess::net_pack( std::ostream& s ) const
 {
   gvt.net_pack( s );
+  __net_pack( s, grp );
   __net_pack( s, mess );
 }
 
 void VTmess::unpack( std::istream& s )
 {
   gvt.unpack( s );
+  __unpack( s, grp );
   __unpack( s, mess );
 }
 
 void VTmess::net_unpack( std::istream& s )
 {
   gvt.net_unpack( s );
+  __net_unpack( s, grp );
   __net_unpack( s, mess );
 }
 
@@ -226,6 +230,12 @@
       ++i;
       ++j;
     }
+    if ( i != l.end() ) {
+      while ( j != r.end() && j->first < i->first ) {
+	vt.push_back( make_pair( j->first, j->second ) );
+	++j;
+      }
+    }
   }
 
   while ( i != l.end() ) {
@@ -240,6 +250,46 @@
   return vt;
 }
 
+vtime_type& operator +=( vtime_type& l, const vtime_type& r )
+{
+  if ( r.empty() ) {
+    return l;
+  }
+
+  if ( l.empty() ) {
+    l = r;
+    return l;
+  }
+
+  vtime_type::iterator i = l.begin();
+  vtime_type::const_iterator j = r.begin();
+
+  while ( i != l.end() && j != r.end() ) {
+    while ( i != l.end() && i->first < j->first ) {
+      ++i;
+    }
+  
+    while ( i != l.end() && j != r.end() && i->first == j->first ) {
+      i->second += j->second;
+      ++i;
+      ++j;
+    }
+
+    while ( i != l.end() && j != r.end() && j->first < i->first ) {
+      l.insert( i, make_pair( j->first, j->second ) );
+      ++i;
+      ++j;
+    }
+  }
+
+  while ( j != r.end() ) {
+    l.push_back( make_pair( j->first, j->second ) );
+    ++j;
+  }
+
+  return l;
+}
+
 // template <>
 vtime_type max( const vtime_type& l, const vtime_type& r )
 {
@@ -281,62 +331,78 @@
   return vt;
 }
 
+vtime& vtime::operator += ( const vtime_proc_type& t )
+{
+  vtime_type::iterator i = vt.begin();
+
+  for ( ; i != vt.end(); ++i ) {
+    if ( i->first > t.first ) {
+      break;
+    } else if ( i->first == t.first ) {
+      i->second += t.second;
+      return *this;
+    }
+  }
+  vt.insert( i, t );
+  return *this;
+}
+
+gvtime& gvtime::operator +=( const vtime_group_type& t )
+{
+  gvtime_type::iterator i = gvt.begin();
+
+  for ( ; i != gvt.end(); ++i ) {
+    if ( i->first > t.first ) {
+      break;
+    } else if ( i->first == t.first ) {
+      i->second += t.second;
+      return *this;
+    }
+  }
+  gvt.insert( i, t );
+  return *this;  
+}
+
 void Proc::mess( const stem::Event_base<VTmess>& ev )
 {
   cout << ev.value().mess << endl;
+
+  cout << ev.value().gvt.gvt << endl;
+
+  cout << order_correct( ev ) << endl;
 }
 
 bool Proc::order_correct( const stem::Event_base<VTmess>& ev )
 {
-  // assume here first_group
-
   gvtime_type::const_iterator gr = ev.value().gvt.gvt.begin();
   gvtime_type::const_iterator ge = ev.value().gvt.gvt.end();
 
-  for ( ; gr != ge; ++gr ) {
-    if ( gr->first == first_group ) {
-      vtime_type vt_tmp = last_vt[first_group] + gr->second.vt;
+  bool fine = false;
 
-      vtime_type::const_iterator i = vt_tmp.begin();
-      vtime_type::const_iterator j = vt[first_group].begin();
+  group_type mgrp = ev.value().grp;
 
-      while ( i != vt_tmp.end() && j != vt[first_group].end() ) {
-	if ( i->first < j->first ) {
-          return false; // really protocol fail: group member was lost
-	}
-	
-	while ( i->first == j->first && i != vt_tmp.end() && j != vt[first_group].end() ) {
-	  if ( i->first == self_id() ) {
-	    if ( i->second != (j->second + 1) ) {
-	      return false;
-	    }
-	  } else {
-	    if ( i->second > j->second ) {
-	      return false;
-	    }
-	  }
-	  ++i;
-	  ++j;
-	}
+  for ( ; gr != ge; ++gr ) { // over all groups
+    if ( gr->first == mgrp ) {
+      vtime_type vt_tmp = last_vt[ev.value().grp] + gr->second.vt;
 
-	if ( i != vt_tmp.end() ) {
-	  return false; // really protocol fail: group member lost
-	}
-
-	while ( j != vt[first_group].end() ) {
-	  if ( j->first == self_id() && j->second != 1 ) {
-	    return false;
-	  }
-	  ++j;
-	}
+      vtime_type::const_iterator i = vt_tmp.begin();
+      if ( vt[mgrp].empty() ) {
+	vtime vt_null;
+	vt_null += make_pair( ev.src(), 1 );
+	cerr << vt_tmp << vt_null.vt;
+	return vt_tmp == vt_null.vt;
+      } else {
+	vtime_type::const_iterator j = vt[mgrp].begin();
       }
     } else {
-      vtime_type vt_tmp = last_vt[second_group] + gr->second.vt;
-      if ( !(vt_tmp <= vt[second_group] )) {
+      vtime_type vt_tmp = last_vt[mgrp] + gr->second.vt;
+      if ( !(vt_tmp <= vt[mgrp] )) {
 	return false;
       }
     }
   }
+
+  return fine;
 }
 
 DEFINE_RESPONSE_TABLE( Proc )
@@ -344,3 +410,36 @@
 END_RESPONSE_TABLE
 
 } // namespace vt
+
+namespace std {
+
+ostream& operator <<( ostream& o, const vt::vtime_proc_type& v )
+{
+  o << "(" << v.first << "," << v.second << ")\n";
+}
+
+ostream& operator <<( ostream& o, const vt::vtime_type& v )
+{
+  o << "[\n";
+  for ( vt::vtime_type::const_iterator i = v.begin(); i != v.end(); ++i ) {
+    o << *i;
+  }
+  o << "]\n";
+}
+
+ostream& operator <<( ostream& o, const vt::vtime_group_type& v )
+{
+  o << 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 << "}\n";
+}
+
+} // namespace std
+

Modified: trunk/complement/explore/test/virtual_time/vtime.h
===================================================================
--- trunk/complement/explore/test/virtual_time/vtime.h	2007-05-22 15:05:03 UTC (rev 1568)
+++ trunk/complement/explore/test/virtual_time/vtime.h	2007-05-23 15:26:04 UTC (rev 1569)
@@ -17,9 +17,10 @@
 
 namespace vt {
 
+typedef stem::addr_type oid_type;
 typedef unsigned vtime_unit_type;
 typedef uint32_t group_type;
-typedef std::pair<stem::addr_type, vtime_unit_type> vtime_proc_type;
+typedef std::pair<oid_type, vtime_unit_type> vtime_proc_type;
 typedef std::list<vtime_proc_type> vtime_type;
 
 inline bool uorder( const vtime_proc_type& l, const vtime_proc_type& r )
@@ -57,6 +58,7 @@
 bool operator <=( const vtime_type& l, const vtime_type& r );
 vtime_type operator -( const vtime_type& l, const vtime_type& r );
 vtime_type operator +( const vtime_type& l, const vtime_type& r );
+vtime_type& operator +=( vtime_type& l, const vtime_type& r );
 
 vtime_type max( const vtime_type& l, const vtime_type& r );
 
@@ -73,10 +75,41 @@
   vtime( const vtime& _vt ) :
     vt( _vt.vt.begin(), _vt.vt.end() )
     { }
+  vtime( const vtime_type& _vt ) :
+    vt( _vt.begin(), _vt.end() )
+    { }
 
   vtime& operator =( const vtime& _vt )
-  { vt.clear(); std::copy( _vt.vt.begin(), _vt.vt.end(), std::back_insert_iterator<vtime_type>(vt) ); }
+    {
+      vt.clear();
+      std::copy( _vt.vt.begin(), _vt.vt.end(), std::back_insert_iterator<vtime_type>(vt) );
+    }
 
+  bool operator ==( const vtime& r ) const
+    { return vt == r.vt; }
+
+  bool operator <=( const vtime& r ) const
+    { return vt <= r.vt; }
+
+  vtime operator -( const vtime& r ) const
+    { return vtime( vt - r.vt ); }
+
+  vtime operator +( const vtime& r ) const
+    { return vtime( vt + r.vt ); }
+
+  vtime& operator +=( const vtime_type& t )
+  {
+    vt += t;
+    return *this;
+  }
+  vtime& operator +=( const vtime& t )
+  {
+    vt += t.vt;
+    return *this;
+  }
+  
+  vtime& operator +=( const vtime_proc_type& );
+    
   vtime_type vt;
 };
 
@@ -98,8 +131,13 @@
     { }
 
   gvtime& operator =( const gvtime& _gvt )
-  { gvt.clear(); std::copy( _gvt.gvt.begin(), _gvt.gvt.end(), std::back_insert_iterator<gvtime_type>(gvt) ); }
+    {
+      gvt.clear();
+      std::copy( _gvt.gvt.begin(), _gvt.gvt.end(), std::back_insert_iterator<gvtime_type>(gvt) );
+    }
 
+  gvtime& operator +=( const vtime_group_type& );
+
   gvtime_type gvt;
 };
 
@@ -119,6 +157,7 @@
     { }
 
   gvtime gvt;
+  group_type grp;
   std::string mess;
 };
 
@@ -155,4 +194,13 @@
 
 } // namespace vt
 
+namespace std {
+
+ostream& operator <<( ostream&, const vt::vtime_proc_type& );
+ostream& operator <<( ostream&, const vt::vtime_type& );
+ostream& operator <<( ostream&, const vt::vtime_group_type& );
+ostream& operator <<( ostream&, const vt::gvtime_type& );
+
+} // namespace std
+
 #endif // __vtime_h

Modified: trunk/complement/explore/test/virtual_time/vtime_main.cc
===================================================================
--- trunk/complement/explore/test/virtual_time/vtime_main.cc	2007-05-22 15:05:03 UTC (rev 1568)
+++ trunk/complement/explore/test/virtual_time/vtime_main.cc	2007-05-23 15:26:04 UTC (rev 1569)
@@ -23,7 +23,15 @@
   stem::Event_base<VTmess> mess( MESS );
   
   mess.dest( 101 );
+
+  vtime_group_type gvt;
+
+  gvt.first = 0; // group
+  gvt.second += make_pair( 101, 1 );
+
   mess.value().mess = "Hello!";
+  mess.value().grp = 0;
+  mess.value().gvt += gvt;
 
   m1.Send( mess );
 


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


