Changeset 8307 in josm

Timestamp:

2015-05-02T00:38:57+02:00 (9 years ago)

Author:

bastiK

Message:

applied #10902 - TMS simultaneous connections (patch by wiktorn)

Location:

trunk/src/org/openstreetmap/josm

Files:

• data/imagery/TMSCachedTileLoaderJob.java (modified) (3 diffs)
• gui/preferences/imagery/TMSSettingsPanel.java (modified) (5 diffs)

trunk/src/org/openstreetmap/josm/data/imagery/TMSCachedTileLoaderJob.java

@@ -6 +6 @@
 import java.net.URL;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executor;
 import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.Semaphore;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
@@ -20 +22 @@
 import org.openstreetmap.gui.jmapviewer.interfaces.TileSource;
 import org.openstreetmap.gui.jmapviewer.tilesources.AbstractTMSTileSource;
+import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.data.cache.BufferedImageCacheEntry;
 import org.openstreetmap.josm.data.cache.CacheEntry;
@@ -42 +45 @@
      */
     public static final IntegerProperty THREAD_LIMIT = new IntegerProperty("imagery.tms.tmsloader.maxjobs", 25);
+
+    /**
+     * Limit definition for per host concurrent connections
+     */
+    public static final IntegerProperty HOST_LIMIT = new IntegerProperty("imagery.tms.tmsloader.maxjobsperhost", 6);
+
+
+    private static class LIFOQueue extends LinkedBlockingDeque<Runnable> {
+        public LIFOQueue(int capacity) {
+            super(capacity);
+        }
+
+        private final static Semaphore getSemaphore(Runnable r) {
+            if (!(r instanceof TMSCachedTileLoaderJob))
+                return null;
+            TMSCachedTileLoaderJob cachedJob = (TMSCachedTileLoaderJob) r;
+            Semaphore limit = HOST_LIMITS.get(cachedJob.getUrl().getHost());
+            if (limit == null) {
+                synchronized(HOST_LIMITS) {
+                    limit = HOST_LIMITS.get(cachedJob.getUrl().getHost());
+                    if (limit == null) {
+                        limit = new Semaphore(HOST_LIMIT.get().intValue());
+                        HOST_LIMITS.put(cachedJob.getUrl().getHost(), limit);
+                    }
+                }
+            }
+            return limit;
+        }
+
+        private boolean acquireSemaphore(Runnable r) {
+            boolean ret = true;
+            Semaphore limit = getSemaphore(r);
+            if (limit != null) {
+                ret = limit.tryAcquire();
+                if (!ret) {
+                    Main.debug("rejecting job because of per host limit");
+                }
+            }
+            return ret;
+        }
+
+        @Override
+        public boolean offer(Runnable t) {
+            return acquireSemaphore(t) && super.offerFirst(t);
+        }
+
+        private Runnable releaseSemaphore(Runnable r) {
+            Semaphore limit = getSemaphore(r);
+            if (limit != null)
+                limit.release();
+            return r;
+        }
+
+        @Override
+        public Runnable remove() {
+            return releaseSemaphore(super.removeFirst());
+        }
+
+        @Override
+        public Runnable poll(long timeout, TimeUnit unit) throws InterruptedException {
+            return releaseSemaphore(super.poll(timeout, unit));
+        }
+
+        @Override
+        public Runnable take() throws InterruptedException {
+            return releaseSemaphore(super.take());
+        }
+    }
+
+    private static Map<String, Semaphore> HOST_LIMITS = new ConcurrentHashMap<>();
+
     /**
      * separate from JCS thread pool for TMS loader, so we can have different thread pools for default JCS
      * and for TMS imagery
      */
-    private static ThreadPoolExecutor DOWNLOAD_JOB_DISPATCHER = new ThreadPoolExecutor(
-            THREAD_LIMIT.get().intValue(), // keep the thread number constant
-            THREAD_LIMIT.get().intValue(), // do not this number of threads
-            30, // keepalive for thread
-            TimeUnit.SECONDS,
-            // make queue of LIFO type - so recently requested tiles will be loaded first (assuming that these are which user is waiting to see)
-            new LinkedBlockingDeque<Runnable>(5) {
-                /* keep the queue size fairly small, we do not want to
-                 download a lot of tiles, that user is not seeing anyway */
-                @Override
-                public boolean offer(Runnable t) {
-                    return super.offerFirst(t);
-                }
-
-                @Override
-                public Runnable remove() {
-                    return super.removeFirst();
-                }
-            }
-            );
+    private static ThreadPoolExecutor DOWNLOAD_JOB_DISPATCHER = getThreadPoolExecutor();
+
+    private static ThreadPoolExecutor getThreadPoolExecutor() {
+        return new ThreadPoolExecutor(
+                THREAD_LIMIT.get().intValue(), // keep the thread number constant
+                THREAD_LIMIT.get().intValue(), // do not this number of threads
+                30, // keepalive for thread
+                TimeUnit.SECONDS,
+                // make queue of LIFO type - so recently requested tiles will be loaded first (assuming that these are which user is waiting to see)
+                new LIFOQueue(5)
+                    /* keep the queue size fairly small, we do not want to
+                     download a lot of tiles, that user is not seeing anyway */
+                );
+    }
+
+    /**
+     * Reconfigures download dispatcher using current values of THREAD_LIMIT and HOST_LIMIT
+     */
+    public static final void reconfigureDownloadDispatcher() {
+        HOST_LIMITS = new ConcurrentHashMap<>();
+        DOWNLOAD_JOB_DISPATCHER = getThreadPoolExecutor();
+    }
+
 
     /**

trunk/src/org/openstreetmap/josm/gui/preferences/imagery/TMSSettingsPanel.java

@@ -33 +33 @@
     private final JSpinner maxElementsOnDisk;
     private final JSpinner maxConcurrentDownloads;
+    private final JSpinner maxDownloadsPerHost;
 
 
@@ -44 +45 @@
         maxElementsOnDisk = new JSpinner(new SpinnerNumberModel(TMSCachedTileLoader.MAX_OBJECTS_ON_DISK.get().intValue(), 0, Integer.MAX_VALUE, 1));
         maxConcurrentDownloads = new JSpinner(new SpinnerNumberModel(TMSCachedTileLoaderJob.THREAD_LIMIT.get().intValue(), 0, Integer.MAX_VALUE, 1));
+        maxDownloadsPerHost = new JSpinner(new SpinnerNumberModel(TMSCachedTileLoaderJob.HOST_LIMIT.get().intValue(), 0, Integer.MAX_VALUE, 1));
 
         add(new JLabel(tr("Auto zoom by default: ")), GBC.std());
@@ -73 +75 @@
         add(maxConcurrentDownloads, GBC.eol());
 
+        add(new JLabel(tr("Maximum concurrent downloads per host: ")), GBC.std());
+        add(GBC.glue(5, 0), GBC.std());
+        add(maxDownloadsPerHost, GBC.eol());
+
+
         add(new JLabel(tr("Maximum elements in disk cache: ")), GBC.std());
         add(GBC.glue(5, 0), GBC.std());
@@ -91 +98 @@
         this.maxElementsOnDisk.setValue(TMSCachedTileLoader.MAX_OBJECTS_ON_DISK.get());
         this.maxConcurrentDownloads.setValue(TMSCachedTileLoaderJob.THREAD_LIMIT.get());
+        this.maxDownloadsPerHost.setValue(TMSCachedTileLoaderJob.HOST_LIMIT.get());
     }
 
@@ -111 +119 @@
         TMSCachedTileLoader.MAX_OBJECTS_ON_DISK.put((Integer) this.maxElementsOnDisk.getValue());
 
-        if (!TMSCachedTileLoaderJob.THREAD_LIMIT.get().equals(this.maxConcurrentDownloads.getValue())) {
-            restartRequired = true;
-            TMSCachedTileLoaderJob.THREAD_LIMIT.put((Integer) this.maxConcurrentDownloads.getValue());
-        }
+        TMSCachedTileLoaderJob.THREAD_LIMIT.put((Integer) this.maxConcurrentDownloads.getValue());
+        TMSCachedTileLoaderJob.HOST_LIMIT.put((Integer) this.maxDownloadsPerHost.getValue());
+        TMSCachedTileLoaderJob.reconfigureDownloadDispatcher();
 
         if (!TMSLayer.PROP_TILECACHE_DIR.get().equals(this.tilecacheDir.getText())) {