Author: toad
Date: 2008-08-28 23:24:33 +0000 (Thu, 28 Aug 2008)
New Revision: 22206

Modified:
   
branches/db4o/freenet/src/freenet/client/async/ClientRequestSchedulerBase.java
   
branches/db4o/freenet/src/freenet/client/async/ClientRequestSchedulerCore.java
   
branches/db4o/freenet/src/freenet/client/async/ClientRequestSchedulerNonPersistent.java
Log:
Delete unused recent-successes code for persistent requests.


Modified: 
branches/db4o/freenet/src/freenet/client/async/ClientRequestSchedulerBase.java
===================================================================
--- 
branches/db4o/freenet/src/freenet/client/async/ClientRequestSchedulerBase.java  
    2008-08-28 23:04:34 UTC (rev 22205)
+++ 
branches/db4o/freenet/src/freenet/client/async/ClientRequestSchedulerBase.java  
    2008-08-28 23:24:33 UTC (rev 22206)
@@ -57,17 +57,15 @@
         * To speed up fetching, a RGA or SVBN must only exist if it is 
non-empty.
         */
        protected final SortedVectorByNumber[] priorities;
-       protected final List /* <BaseSendableGet> */ recentSuccesses;
        protected transient ClientRequestScheduler sched;
        /** Transient even for persistent scheduler. */
        protected transient Set<KeyListener> keyListeners;

        abstract boolean persistent();

-       protected ClientRequestSchedulerBase(boolean forInserts, boolean 
forSSKs, List recentSuccesses) {
+       protected ClientRequestSchedulerBase(boolean forInserts, boolean 
forSSKs) {
                this.isInsertScheduler = forInserts;
                this.isSSKScheduler = forSSKs;
-               this.recentSuccesses = recentSuccesses;
                keyListeners = new HashSet<KeyListener>();
                priorities = new 
SortedVectorByNumber[RequestStarter.NUMBER_OF_PRIORITY_CLASSES];
                logMINOR = Logger.shouldLog(Logger.MINOR, 
ClientRequestSchedulerBase.class);
@@ -170,16 +168,8 @@
        }

        public void succeeded(BaseSendableGet succeeded, ObjectContainer 
container) {
-               if(isInsertScheduler) return;
-               if(persistent()) {
-                       container.activate(succeeded, 1);
-               }
-               if(succeeded.isEmpty(container)) return;
-                       if(logMINOR)
-                               Logger.minor(this, "Recording successful fetch 
from "+succeeded);
-                       recentSuccesses.add(succeeded);
-                       while(recentSuccesses.size() > 8)
-                               recentSuccesses.remove(0);
+               // Do nothing.
+               // FIXME: Keep a list of recently succeeded ClientRequester's.
        }

        public synchronized void addPendingKeys(KeyListener listener) {

Modified: 
branches/db4o/freenet/src/freenet/client/async/ClientRequestSchedulerCore.java
===================================================================
--- 
branches/db4o/freenet/src/freenet/client/async/ClientRequestSchedulerCore.java  
    2008-08-28 23:04:34 UTC (rev 22205)
+++ 
branches/db4o/freenet/src/freenet/client/async/ClientRequestSchedulerCore.java  
    2008-08-28 23:24:33 UTC (rev 22206)
@@ -98,7 +98,7 @@
        }

        ClientRequestSchedulerCore(Node node, boolean forInserts, boolean 
forSSKs, ObjectContainer selectorContainer, long cooldownTime) {
-               super(forInserts, forSSKs, 
selectorContainer.ext().collections().newLinkedList());
+               super(forInserts, forSSKs);
                this.nodeDBHandle = node.nodeDBHandle;
                if(!forInserts) {
                        this.persistentCooldownQueue = new 
PersistentCooldownQueue();
@@ -112,9 +112,6 @@
        private void onStarted(ObjectContainer container, long cooldownTime, 
ClientRequestScheduler sched, ClientContext context) {
                super.onStarted();
                System.err.println("insert scheduler: "+isInsertScheduler);
-               if(recentSuccesses == null)
-                       System.err.println("recentSuccesses is null");
-               ((Db4oList)recentSuccesses).activationDepth(1);
                if(!isInsertScheduler) {
                        persistentCooldownQueue.setCooldownTime(cooldownTime);
                }
@@ -459,7 +456,7 @@
                         * be to have recentSuccesses be a list of 
ClientRequester's instead, 
                         * like we do on trunk. */
                        if(!req.persistent()) {
-                       List recent = req.persistent() ? recentSuccesses : 
schedTransient.recentSuccesses;
+                       List recent = schedTransient.recentSuccesses;
                        SendableRequest altReq = null;
                        if(!recent.isEmpty()) {
                                if(random.nextBoolean()) {

Modified: 
branches/db4o/freenet/src/freenet/client/async/ClientRequestSchedulerNonPersistent.java
===================================================================
--- 
branches/db4o/freenet/src/freenet/client/async/ClientRequestSchedulerNonPersistent.java
     2008-08-28 23:04:34 UTC (rev 22205)
+++ 
branches/db4o/freenet/src/freenet/client/async/ClientRequestSchedulerNonPersistent.java
     2008-08-28 23:24:33 UTC (rev 22206)
@@ -6,12 +6,14 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import com.db4o.ObjectContainer;

 import freenet.keys.Key;
+import freenet.node.BaseSendableGet;
 import freenet.node.SendableRequest;
 import freenet.support.Logger;

@@ -22,26 +24,16 @@
 class ClientRequestSchedulerNonPersistent extends ClientRequestSchedulerBase {

        private boolean logMINOR;
-       /**
-        * Structure:
-        * array (by priority) -> // one element per possible priority
-        * SortedVectorByNumber (by # retries) -> // contains each current 
#retries
-        * RandomGrabArray // contains each element, allows fast 
fetch-and-drop-a-random-element
-        * 
-        * To speed up fetching, a RGA or SVBN must only exist if it is 
non-empty.
-        */
-       final LinkedList /* <BaseSendableGet> */ recentSuccesses;

        /** All pending gets by key. Used to automatically satisfy pending 
requests when either the key is fetched by
         * an overlapping request, or it is fetched by a request from another 
node. Operations on this are synchronized on
         * itself. */
        protected final Map /* <Key, SendableGet[]> */ pendingKeys;

-       protected final Map allRequestsByClientRequest;
+       protected final List /* <BaseSendableGet> */ recentSuccesses;

        ClientRequestSchedulerNonPersistent(ClientRequestScheduler sched, 
boolean forInserts, boolean forSSKs) {
-               super(forInserts, forSSKs, new LinkedList());
-               allRequestsByClientRequest = new HashMap();
+               super(forInserts, forSSKs);
                this.sched = sched;
                recentSuccesses = new LinkedList();
                if(forInserts)
@@ -68,5 +60,21 @@
                        return pendingKeys.size();
                else return 0;
        }
-       
+
+       public void succeeded(BaseSendableGet succeeded, ObjectContainer 
container) {
+               // Do nothing.
+               // FIXME: Keep a list of recently succeeded ClientRequester's.
+               if(isInsertScheduler) return;
+               if(persistent()) {
+                       container.activate(succeeded, 1);
+               }
+               if(succeeded.isEmpty(container)) return;
+                       if(logMINOR)
+                               Logger.minor(this, "Recording successful fetch 
from "+succeeded);
+                       recentSuccesses.add(succeeded);
+                       while(recentSuccesses.size() > 8)
+                               recentSuccesses.remove(0);
+       }
+
+
 }


Reply via email to