zothar at freenetproject.org wrote:
> Author: zothar
> Date: 2006-05-13 00:02:33 +0000 (Sat, 13 May 2006)
> New Revision: 8687
>
> Modified:
> trunk/freenet/src/freenet/io/comm/UdpSocketManager.java
> trunk/freenet/src/freenet/node/PacketSender.java
> trunk/freenet/src/freenet/node/PeerNode.java
> Log:
> Don't try to send queued messages or keepalive packets to backed off nodes.
> Increase the size of the maximum unmatched FIFO and make the limit a variable.
>
My apologies for such a major change in r8687. At the time, I thought I
was fixing an oversight and optimizing a tight loop and it didn't appear
to change my node's behavior in the half hour or so I was running it
before committing (though the changes may explain the large backoff
sizes some of my peers had gotten from my node by the time I looked at
it again today).
It seems I greatly misunderstood what "backing off" mean and I may not
be the only one. I now understand being "backed off" from a peer to
mean that we will not route any new messages to that peer rather than we
will generally stop talking to that peer. Thus I propose the following
name-only changes. I'll commit them if I get consensus that they're a
good idea.
Index: clients/http/DarknetConnectionsToadlet.java
===================================================================
--- clients/http/DarknetConnectionsToadlet.java (revision 8701)
+++ clients/http/DarknetConnectionsToadlet.java (working copy)
@@ -102,9 +102,9 @@
String[][] messageTypesRows = new String[peerNodes.length][];
for(int i=0;i<peerNodes.length;i++) {
PeerNode pn = peerNodes[i];
- long backedOffUntil = pn.getBackedOffUntil();
- boolean backedOffNow = (now < backedOffUntil);
- int backoff = (int)(Math.max(backedOffUntil - now, 0));
+ long routingBackedOffUntil = pn.getRoutingBackedOffUntil();
+ boolean routingBackedOffNow = (now < routingBackedOffUntil);
+ int backoff = (int)(Math.max(routingBackedOffUntil - now, 0));
long idle = pn.lastReceivedPacketTime();
// Elements must be HTML encoded.
@@ -115,7 +115,7 @@
Object status;
if(pn.isConnected()) {
status = CONNECTED;
- if(backedOffNow) {
+ if(routingBackedOffNow) {
status = BACKED_OFF;
}
} else if(pn.hasCompletedHandshake() &&
!Version.checkGoodVersion(pn.getVersion())) {
@@ -130,7 +130,7 @@
row[3] = pn.getDetectedPeer() != null ?
HTMLEncoder.encode(pn.getDetectedPeer().toString()) : "(address unknown)";
row[4] = HTMLEncoder.encode(pn.getVersion());
row[5] = new Double(pn.getLocation().getValue());
- row[6] = backoff/1000 + "/" + pn.getBackoffLength()/1000;
+ row[6] = backoff/1000 + "/" +
pn.getRoutingBackoffLength()/1000;
if (idle == -1) row[7] = " ";
else row[7] = new Long((now - idle) / 60000);
row[8] = "<input type=\"checkbox\"
name=\"delete_node_"+pn.hashCode()+"\" />";
Index: node/PeerNode.java
===================================================================
--- node/PeerNode.java (revision 8701)
+++ node/PeerNode.java (working copy)
@@ -1106,7 +1106,7 @@
public String getStatus() {
return
- (isConnected ? "CONNECTED " : "DISCONNECTED") + " " +
getPeer()+" "+myName+" "+currentLocation.getValue()+" "+getVersion()+"
backoff: "+backoffLength+" ("+(Math.max(backedOffUntil -
System.currentTimeMillis(),0))+")";
+ (isConnected ? "CONNECTED " : "DISCONNECTED") + " " +
getPeer()+" "+myName+" "+currentLocation.getValue()+" "+getVersion()+"
backoff: "+routingBackoffLength+" ("+(Math.max(routingBackedOffUntil -
System.currentTimeMillis(),0))+")";
}
public String getFreevizOutput() {
@@ -1221,26 +1221,26 @@
return hashCode;
}
- private final Object backoffSync = new Object();
+ private final Object routingBackoffSync = new Object();
- public boolean isBackedOff() {
- synchronized(backoffSync) {
- if(System.currentTimeMillis() < backedOffUntil) {
- Logger.minor(this, "Is backed off");
+ public boolean isRoutingBackedOff() {
+ synchronized(routingBackoffSync) {
+ if(System.currentTimeMillis() < routingBackedOffUntil) {
+ Logger.minor(this, "Routing is backed off");
return true;
} else return false;
}
}
- long backedOffUntil = -1;
- /** Initial nominal backoff length */
- final int INITIAL_BACKOFF_LENGTH = 5000;
+ long routingBackedOffUntil = -1;
+ /** Initial nominal routing backoff length */
+ final int INITIAL_ROUTING_BACKOFF_LENGTH = 5000;
/** Double every time */
- final int BACKOFF_MULTIPLIER = 2;
+ final int ROUTING_BACKOFF_MULTIPLIER = 2;
/** Maximum: 24 hours */
- final int MAX_BACKOFF_LENGTH = 24*60*60*1000;
- /** Current nominal backoff length */
- int backoffLength = INITIAL_BACKOFF_LENGTH;
+ final int MAX_ROUTING_BACKOFF_LENGTH = 24*60*60*1000;
+ /** Current nominal routing backoff length */
+ int routingBackoffLength = INITIAL_ROUTING_BACKOFF_LENGTH;
/**
* Got a local RejectedOverload.
@@ -1248,36 +1248,36 @@
*/
public void localRejectedOverload() {
Logger.minor(this, "Local rejected overload on "+this);
- synchronized(backoffSync) {
+ synchronized(routingBackoffSync) {
long now = System.currentTimeMillis();
// Don't back off any further if we are already backed off
- if(now > backedOffUntil) {
- backoffLength = backoffLength * BACKOFF_MULTIPLIER;
- if(backoffLength > MAX_BACKOFF_LENGTH)
- backoffLength = MAX_BACKOFF_LENGTH;
- int x = node.random.nextInt(backoffLength);
- backedOffUntil = now + x;
- Logger.minor(this, "Backing off:
backoffLength="+backoffLength+", until "+x+"ms on "+getPeer());
+ if(now > routingBackedOffUntil) {
+ routingBackoffLength = routingBackoffLength *
ROUTING_BACKOFF_MULTIPLIER;
+ if(routingBackoffLength > MAX_ROUTING_BACKOFF_LENGTH)
+ routingBackoffLength = MAX_ROUTING_BACKOFF_LENGTH;
+ int x = node.random.nextInt(routingBackoffLength);
+ routingBackedOffUntil = now + x;
+ Logger.minor(this, "Backing off:
routingBackoffLength="+routingBackoffLength+", until "+x+"ms on
"+getPeer());
} else {
- Logger.minor(this, "Ignoring localRejectedOverload:
"+(backedOffUntil-now)+"ms remaining on backoff on "+getPeer());
+ Logger.minor(this, "Ignoring localRejectedOverload:
"+(routingBackedOffUntil-now)+"ms remaining on routing backoff on
"+getPeer());
}
}
}
/**
* Didn't get RejectedOverload.
- * Reset backoff.
+ * Reset routing backoff.
*/
public void successNotOverload() {
Logger.minor(this, "Success not overload on "+this);
- synchronized(backoffSync) {
+ synchronized(routingBackoffSync) {
long now = System.currentTimeMillis();
// Don't un-backoff if still backed off
- if(now > backedOffUntil) {
- backoffLength = INITIAL_BACKOFF_LENGTH;
- Logger.minor(this, "Resetting backoff on "+getPeer());
+ if(now > routingBackedOffUntil) {
+ routingBackoffLength = INITIAL_ROUTING_BACKOFF_LENGTH;
+ Logger.minor(this, "Resetting routing backoff on
"+getPeer());
} else {
- Logger.minor(this, "Ignoring successNotOverload:
"+(backedOffUntil-now)+"ms remaining on backoff on "+getPeer());
+ Logger.minor(this, "Ignoring successNotOverload:
"+(routingBackedOffUntil-now)+"ms remaining on routing backoff on
"+getPeer());
}
}
}
@@ -1356,12 +1356,12 @@
return myName;
}
- public int getBackoffLength() {
- return this.backoffLength;
+ public int getRoutingBackoffLength() {
+ return this.routingBackoffLength;
}
- public long getBackedOffUntil() {
- return backedOffUntil;
+ public long getRoutingBackedOffUntil() {
+ return routingBackedOffUntil;
}
public boolean hasCompletedHandshake() {
Index: node/PeerManager.java
===================================================================
--- node/PeerManager.java (revision 8701)
+++ node/PeerManager.java (working copy)
@@ -395,8 +395,8 @@
Logger.minor(this, "Skipping (not connected):
"+p.getPeer());
continue;
}
- if(p.isBackedOff()) {
- Logger.minor(this, "Skipping (backed off): "+p.getPeer());
+ if(p.isRoutingBackedOff()) {
+ Logger.minor(this, "Skipping (routing backed off):
"+p.getPeer());
continue;
}
count++;
