Author: toad
Date: 2008-05-22 18:46:18 +0000 (Thu, 22 May 2008)
New Revision: 20046

Modified:
   branches/db4o/freenet/src/freenet/client/async/ClientRequestScheduler.java
   branches/db4o/freenet/src/freenet/client/async/CooldownQueue.java
   branches/db4o/freenet/src/freenet/client/async/PersistentCooldownQueue.java
   branches/db4o/freenet/src/freenet/client/async/RequestCooldownQueue.java
Log:
More efficient if we return a whole load of keys. At least for the persistent 
case, which will be the more common.

Modified: 
branches/db4o/freenet/src/freenet/client/async/ClientRequestScheduler.java
===================================================================
--- branches/db4o/freenet/src/freenet/client/async/ClientRequestScheduler.java  
2008-05-22 18:38:13 UTC (rev 20045)
+++ branches/db4o/freenet/src/freenet/client/async/ClientRequestScheduler.java  
2008-05-22 18:46:18 UTC (rev 20046)
@@ -360,8 +360,12 @@
        private void moveKeysFromCooldownQueue(CooldownQueue queue, 
ObjectContainer container) {
                if(queue == null) return;
                long now = System.currentTimeMillis();
-               Key key;
-               while((key = queue.removeKeyBefore(now, container)) != null) { 
+               final int MAX_KEYS = 1024;
+               while(true) {
+               Key[] keys = queue.removeKeyBefore(now, container, MAX_KEYS);
+               if(keys == null) return;
+               for(int j=0;j<keys.length;j++) {
+                       Key key = keys[j];
                        if(logMINOR) Logger.minor(this, "Restoring key: "+key);
                        SendableGet[] gets = 
schedCore.getClientsForPendingKey(key);
                        SendableGet[] transientGets = 
schedTransient.getClientsForPendingKey(key);
@@ -378,6 +382,8 @@
                                        
transientGets[i].requeueAfterCooldown(key, now);
                        }
                }
+               if(keys.length < MAX_KEYS) return;
+               }
        }

        public long countQueuedRequests() {

Modified: branches/db4o/freenet/src/freenet/client/async/CooldownQueue.java
===================================================================
--- branches/db4o/freenet/src/freenet/client/async/CooldownQueue.java   
2008-05-22 18:38:13 UTC (rev 20045)
+++ branches/db4o/freenet/src/freenet/client/async/CooldownQueue.java   
2008-05-22 18:46:18 UTC (rev 20046)
@@ -17,9 +17,9 @@

        /**
         * Remove a key whose cooldown time has passed.
-        * @return Either a Key or null if no keys have passed their cooldown 
time.
+        * @return Either an array of Key's or null if no keys have passed 
their cooldown time.
         */
-       public abstract Key removeKeyBefore(long now, ObjectContainer 
container);
+       public abstract Key[] removeKeyBefore(long now, ObjectContainer 
container, int maxKeys);

        /**
         * @return True if the key was found.

Modified: 
branches/db4o/freenet/src/freenet/client/async/PersistentCooldownQueue.java
===================================================================
--- branches/db4o/freenet/src/freenet/client/async/PersistentCooldownQueue.java 
2008-05-22 18:38:13 UTC (rev 20045)
+++ branches/db4o/freenet/src/freenet/client/async/PersistentCooldownQueue.java 
2008-05-22 18:46:18 UTC (rev 20046)
@@ -3,6 +3,8 @@
  * http://www.gnu.org/ for further details of the GPL. */
 package freenet.client.async;

+import java.util.ArrayList;
+
 import com.db4o.ObjectContainer;
 import com.db4o.ObjectSet;
 import com.db4o.query.Predicate;
@@ -67,7 +69,7 @@
                return found;
        }

-       public Key removeKeyBefore(final long now, ObjectContainer container) {
+       public Key[] removeKeyBefore(final long now, ObjectContainer container, 
int maxCount) {
                // Will be called repeatedly until no more keys are returned, 
so it doesn't
                // matter very much if they're not in order.
                ObjectSet results = container.query(new Predicate() {
@@ -78,9 +80,12 @@
                        }
                });
                if(results.hasNext()) {
-                       Item i = (Item) results.next();
-                       container.delete(i);
-                       return i.key;
+                       ArrayList v = new ArrayList(Math.min(maxCount, 
results.size()));
+                       while(results.hasNext() && v.size() < maxCount) {
+                               Item i = (Item) results.next();
+                               v.add(i.key);
+                       }
+                       return (Key[]) v.toArray(new Key[v.size()]);
                } else
                        return null;
        }

Modified: 
branches/db4o/freenet/src/freenet/client/async/RequestCooldownQueue.java
===================================================================
--- branches/db4o/freenet/src/freenet/client/async/RequestCooldownQueue.java    
2008-05-22 18:38:13 UTC (rev 20045)
+++ branches/db4o/freenet/src/freenet/client/async/RequestCooldownQueue.java    
2008-05-22 18:46:18 UTC (rev 20046)
@@ -3,6 +3,8 @@
  * http://www.gnu.org/ for further details of the GPL. */
 package freenet.client.async;

+import java.util.ArrayList;
+
 import com.db4o.ObjectContainer;

 import freenet.keys.Key;
@@ -115,7 +117,8 @@
        /* (non-Javadoc)
         * @see freenet.client.async.CooldownQueue#removeKeyBefore(long)
         */
-       public synchronized Key removeKeyBefore(long now, ObjectContainer 
container) {
+       public synchronized Key[] removeKeyBefore(long now, ObjectContainer 
container, int maxKeys) {
+               ArrayList v = new ArrayList();
                logMINOR = Logger.shouldLog(Logger.MINOR, this);
                boolean foundIT = false;
                if(Logger.shouldLog(Logger.DEBUG, this)) {
@@ -130,7 +133,7 @@
                while(true) {
                        if(startPtr == endPtr) {
                                if(logMINOR) Logger.minor(this, "No keys 
queued");
-                               return null;
+                               return (Key[]) v.toArray(new Key[v.size()]);
                        }
                        long time = times[startPtr];
                        Key key = keys[startPtr];
@@ -145,7 +148,7 @@
                        } else {
                                if(time > now) {
                                        if(logMINOR) Logger.minor(this, "First 
key is later at time "+time);
-                                       return null;
+                                       return (Key[]) v.toArray(new 
Key[v.size()]);
                                }
                                times[startPtr] = 0;
                                keys[startPtr] = null;
@@ -154,7 +157,7 @@
                                if(startPtr == times.length) startPtr = 0;
                        }
                        if(logMINOR) Logger.minor(this, "Returning key "+key);
-                       return key;
+                       v.add(key);
                }
        }



Reply via email to