Author: toad
Date: 2006-05-31 20:01:59 +0000 (Wed, 31 May 2006)
New Revision: 8960

Modified:
   trunk/freenet/src/freenet/io/xfer/BlockTransmitter.java
   trunk/freenet/src/freenet/node/Node.java
   trunk/freenet/src/freenet/node/Version.java
   trunk/freenet/src/freenet/support/math/TimeDecayingRunningAverage.java
Log:
764: More work on bwlimitDelayTime.

Modified: trunk/freenet/src/freenet/io/xfer/BlockTransmitter.java
===================================================================
--- trunk/freenet/src/freenet/io/xfer/BlockTransmitter.java     2006-05-31 
19:22:38 UTC (rev 8959)
+++ trunk/freenet/src/freenet/io/xfer/BlockTransmitter.java     2006-05-31 
20:01:59 UTC (rev 8960)
@@ -257,6 +257,8 @@

                                        long nowNS = System.currentTimeMillis() 
* 1000 * 1000;

+                                       Logger.minor(this, 
"Now="+nowNS/(1000*1000));
+                                       
                                        long endTime = -1;

                                        boolean thenSend = true;
@@ -268,22 +270,31 @@
                                                nowNS = 
System.currentTimeMillis() * 1000 * 1000;

                                                // Update time if necessary to 
avoid spurts
-                                               if(hardLastPacketSendTimeNSec < 
(nowNS - minPacketDelayNSec))
+                                               if(hardLastPacketSendTimeNSec < 
(nowNS - minPacketDelayNSec)) {
+                                                       Logger.minor(this, 
"Updating hard limit counter - was "+hardLastPacketSendTimeNSec/1000);
                                                        
hardLastPacketSendTimeNSec = nowNS - minPacketDelayNSec;
+                                                       Logger.minor(this, 
"Updated hard limit counter - now "+hardLastPacketSendTimeNSec/1000);
+                                               }

                                                // Wait until the next send 
window
                                                long 
newHardLastPacketSendTimeNS =
                                                        
hardLastPacketSendTimeNSec + minPacketDelayNSec;

+                                               Logger.minor(this, "Waiting for 
"+minPacketDelayNSec+" until "+newHardLastPacketSendTimeNS/1000);
+                                               
                                                long newHardLastPacketSendTime =
                                                        
newHardLastPacketSendTimeNS / (1000 * 1000);

                                                long earliestSendTime = 
startCycleTime + delay;

+                                               Logger.minor(this, "Earliest 
time by hard limit: "+newHardLastPacketSendTime);
+                                               Logger.minor(this, "Earliest 
time by throttle:   "+earliestSendTime);
+                                               
                                                if(earliestSendTime > 
newHardLastPacketSendTime) {
                                                        // Don't clog up other 
senders!
                                                        thenSend = false;
                                                        endTime = 
earliestSendTime;
+                                                       Logger.minor(this, 
"Looping");
                                                } else {
                                                        
hardLastPacketSendTimeNSec = newHardLastPacketSendTimeNS;
                                                        endTime = 
hardLastPacketSendTimeNSec / (1000 * 1000);
@@ -298,12 +309,14 @@
                                                        // However, after 1 
hour we forget our burst rights.
                                                        if(nowNS - 
softLastPacketSendTimeNSec > softLimitPeriodNSec) {
                                                                
softLastPacketSendTimeNSec = nowNS - (softLimitPeriodNSec);
+                                                               
Logger.minor(this, "Updating soft limit");
                                                        }

                                                        
softLastPacketSendTimeNSec += minSoftDelayNSec;

                                                        
if(softLastPacketSendTimeNSec > hardLastPacketSendTimeNSec) {
                                                                endTime = 
((hardLastPacketSendTimeNSec = softLastPacketSendTimeNSec) / (1000 * 1000));
+                                                               
Logger.minor(this, "endTime now "+endTime+" because of soft limit");
                                                        }
                                                }
                                        }
@@ -324,6 +337,7 @@
                                                        return true;
                                                now = 
System.currentTimeMillis();
                                        }
+                                       Logger.minor(this, "Completed wait at 
"+now);

                                        nowNS = now * 1000 * 1000;

@@ -507,6 +521,7 @@
                        if(hardLastPacketSendTimeNSec < (nowNS - 
minPacketDelayNSec)) {
                                // Can send immediately!
                        } else {
+                               Logger.minor(BlockTransmitter.class, "Is 
contended (hard limit)");
                                return false; // is contended.
                        }

@@ -522,9 +537,10 @@
                                softLastPacketSendTimeNSec = nowNS - 
(softLimitPeriodNSec);
                        }

-                       softLastPacketSendTimeNSec += minSoftDelayNSec;
+                       //softLastPacketSendTimeNSec += minSoftDelayNSec;

-                       if(softLastPacketSendTimeNSec > nowNS) {
+                       if(softLastPacketSendTimeNSec + minSoftDelayNSec > 
nowNS) {
+                               Logger.minor(BlockTransmitter.class, "Is 
contended (soft limit)");
                                // Can't send immediately due to soft limit.
                                return false;
                        }

Modified: trunk/freenet/src/freenet/node/Node.java
===================================================================
--- trunk/freenet/src/freenet/node/Node.java    2006-05-31 19:22:38 UTC (rev 
8959)
+++ trunk/freenet/src/freenet/node/Node.java    2006-05-31 20:01:59 UTC (rev 
8960)
@@ -1957,8 +1957,12 @@

        if(now - lastCheckedUncontended > 1000) {
                lastCheckedUncontended = now;
-               if(BlockTransmitter.isUncontended())
+               if(BlockTransmitter.isUncontended()) {
+                       Logger.minor(this, "Reporting 0 because throttle 
uncontended: now "+throttledPacketSendAverage.currentValue());
                        throttledPacketSendAverage.report(0);
+                       Logger.minor(this, "New average: 
"+throttledPacketSendAverage.currentValue());
+               } else
+                       Logger.minor(this, "Not uncontended");
        }

        // Round trip time

Modified: trunk/freenet/src/freenet/node/Version.java
===================================================================
--- trunk/freenet/src/freenet/node/Version.java 2006-05-31 19:22:38 UTC (rev 
8959)
+++ trunk/freenet/src/freenet/node/Version.java 2006-05-31 20:01:59 UTC (rev 
8960)
@@ -18,7 +18,7 @@
        public static final String protocolVersion = "1.0";

        /** The build number of the current revision */
-       private static final int buildNumber = 763;
+       private static final int buildNumber = 764;

        /** Oldest build of Fred we will talk to */
        private static final int lastGoodBuild = 761;

Modified: trunk/freenet/src/freenet/support/math/TimeDecayingRunningAverage.java
===================================================================
--- trunk/freenet/src/freenet/support/math/TimeDecayingRunningAverage.java      
2006-05-31 19:22:38 UTC (rev 8959)
+++ trunk/freenet/src/freenet/support/math/TimeDecayingRunningAverage.java      
2006-05-31 20:01:59 UTC (rev 8960)
@@ -173,10 +173,10 @@
                  now - lastReportTime;
             double thisHalfLife = halfLife;
             long uptime = now - createdTime;
-            if(uptime < thisHalfLife) thisHalfLife = uptime;
+            if((uptime / 4) < thisHalfLife) thisHalfLife = (uptime / 4);
             if(thisHalfLife == 0) thisHalfLife = 1;
             double changeFactor =
-               Math.pow(0.5, thisInterval / thisHalfLife);
+               Math.pow(0.5, ((double)thisInterval) / thisHalfLife);
             weightedTotal = weightedTotal * changeFactor + d;
             totalWeights = totalWeights * changeFactor + 1.0;
             if(logDEBUG)


Reply via email to