Author: mrogers
Date: 2006-10-31 21:14:58 +0000 (Tue, 31 Oct 2006)
New Revision: 10772

Modified:
   trunk/apps/load-balancing-sims/phase7/sim/Node.java
   trunk/apps/load-balancing-sims/phase7/sim/Peer.java
   trunk/apps/load-balancing-sims/phase7/sim/Sim.java
   trunk/apps/load-balancing-sims/phase7/sim/generators/SimplePublisher.java
Log:
No longer hangs - hooray for voodoo

Modified: trunk/apps/load-balancing-sims/phase7/sim/Node.java
===================================================================
--- trunk/apps/load-balancing-sims/phase7/sim/Node.java 2006-10-31 20:48:55 UTC 
(rev 10771)
+++ trunk/apps/load-balancing-sims/phase7/sim/Node.java 2006-10-31 21:14:58 UTC 
(rev 10772)
@@ -8,10 +8,6 @@

 public class Node implements EventTarget
 {
-       // Token bucket bandwidth limiter
-       public final static int BUCKET_RATE = 30000; // Bytes per second
-       public final static int BUCKET_SIZE = 60000; // Burst size in bytes
-       
        public double location; // Routing location
        public NetworkInterface net;
        private HashMap<Integer,Peer> peers; // Look up a peer by its address
@@ -39,14 +35,14 @@
                peers = new HashMap<Integer,Peer>();
                recentlySeenRequests = new HashSet<Integer>();
                messageHandlers = new HashMap<Integer,MessageHandler>();
-               chkStore = new LruCache<Integer> (10);
-               chkCache = new LruCache<Integer> (10);
-               sskStore = new LruMap<Integer,Integer> (10);
-               sskCache = new LruMap<Integer,Integer> (10);
-               pubKeyCache = new LruCache<Integer> (10);
+               chkStore = new LruCache<Integer> (1000);
+               chkCache = new LruCache<Integer> (1000);
+               sskStore = new LruMap<Integer,Integer> (1000);
+               sskCache = new LruMap<Integer,Integer> (1000);
+               pubKeyCache = new LruCache<Integer> (1000);
                if (Math.random() < 0.5) decrementMaxHtl = true;
                if (Math.random() < 0.25) decrementMinHtl = true;
-               bandwidth = new TokenBucket (BUCKET_RATE, BUCKET_SIZE);
+               bandwidth = new TokenBucket (30000, 60000);
        }

        // Return true if a connection was added, false if already connected
@@ -398,7 +394,8 @@
                        timerRunning = false;
                }
                else {
-                       double sleep = Math.max (deadline - Event.time(), 0.0);
+                       double sleep = deadline - Event.time();
+                       if (sleep < Peer.MIN_SLEEP) sleep = Peer.MIN_SLEEP;
                        // log ("sleeping for " + sleep + " seconds");
                        Event.schedule (this, sleep, CHECK_TIMEOUTS, null);
                }

Modified: trunk/apps/load-balancing-sims/phase7/sim/Peer.java
===================================================================
--- trunk/apps/load-balancing-sims/phase7/sim/Peer.java 2006-10-31 20:48:55 UTC 
(rev 10771)
+++ trunk/apps/load-balancing-sims/phase7/sim/Peer.java 2006-10-31 21:14:58 UTC 
(rev 10772)
@@ -257,9 +257,9 @@
                // Send as many packets as possible
                while (send());

-               log (txBuffer.size() + " packets in flight");
                double now = Event.time();
                if (txBuffer.isEmpty()) return deadline (now);
+               log (txBuffer.size() + " packets in flight");

                for (Packet p : txBuffer) {
                        if (now - p.sent > RTO * rtt + MAX_DELAY) {

Modified: trunk/apps/load-balancing-sims/phase7/sim/Sim.java
===================================================================
--- trunk/apps/load-balancing-sims/phase7/sim/Sim.java  2006-10-31 20:48:55 UTC 
(rev 10771)
+++ trunk/apps/load-balancing-sims/phase7/sim/Sim.java  2006-10-31 21:14:58 UTC 
(rev 10772)
@@ -8,6 +8,7 @@
        private final double SPEED = 20000; // Bytes per second
        private final double LATENCY = 0.1; // Latency of all links in seconds
        private final double RATE = 0.01; // Inserts per second
+       private final int INSERTS = 50;
        private Node[] nodes;

        public Sim()
@@ -23,7 +24,8 @@
                makeKleinbergNetwork();

                // One publisher, ten randomly chosen readers
-               SimplePublisher pub = new SimplePublisher (RATE, nodes[0]);
+               SimplePublisher pub
+                       = new SimplePublisher (RATE, INSERTS, nodes[0]);
                int readers = 0;
                while (readers < 10) {
                        int index = (int) (Math.random() * NODES);
@@ -31,7 +33,6 @@
                }

                // Run the simulation
-               Event.duration = 3600.0;
                Event.run();
        }


Modified: 
trunk/apps/load-balancing-sims/phase7/sim/generators/SimplePublisher.java
===================================================================
--- trunk/apps/load-balancing-sims/phase7/sim/generators/SimplePublisher.java   
2006-10-31 20:48:55 UTC (rev 10771)
+++ trunk/apps/load-balancing-sims/phase7/sim/generators/SimplePublisher.java   
2006-10-31 21:14:58 UTC (rev 10772)
@@ -10,12 +10,14 @@
 public class SimplePublisher implements EventTarget
 {
        public final double rate; // Inserts per second
+       private int inserts; // Publish this many inserts (0 for unlimited)
        private Node node; // The publisher's node
        private HashSet<Node> readers; // The readers' nodes

-       public SimplePublisher (double rate, Node node)
+       public SimplePublisher (double rate, int inserts, Node node)
        {
                this.rate = rate;
+               this.inserts = inserts;
                this.node = node;
                readers = new HashSet<Node>();
                // Schedule the first insert
@@ -37,10 +39,11 @@
                Event.schedule (node, 0.0, Node.INSERT_CHK, key);
                // Inform each reader after an average of ten minutes
                for (Node n : readers) {
-                       double delay = -Math.log (Math.random()) * 600.0;
+                       double delay = 595.0 + Math.random() * 10.0;
                        Event.schedule (n, delay, Node.REQUEST_CHK, key);
                }
-               // Schedule the next insert
+               // Schedule the next insert after an exp. distributed delay
+               if (inserts > 0 && --inserts == 0) return;
                double delay = -Math.log (Math.random()) / rate;
                Event.schedule (this, delay, PUBLISH, null);
        }


Reply via email to