clear model cache when datasource state is changed to STATE_AVAILABLE

Author: thurka

visualvm/application/src/org/graalvm/visualvm/application/Application.java

@@ -59,6 +59,7 @@ public abstract class Application extends DataSource implements Stateful {
     private String id;
     private Host host;
     private int state = STATE_AVAILABLE;
+    private int modCount;
 
 
     /**
@@ -116,9 +117,16 @@ public final synchronized int getState() {
         return state;
     }
 
+    public final int getModCount() {
+        return modCount;
+    }
+
     protected final synchronized void setState(final int newState) {
         final int oldState = state;
         state = newState;
+        if (oldState != newState && newState == STATE_AVAILABLE) {
+            modCount++;
+        }
         if (DataSource.EVENT_QUEUE.isRequestProcessorThread())
             getChangeSupport().firePropertyChange(PROPERTY_STATE, oldState, newState);
         else DataSource.EVENT_QUEUE.post(new Runnable() {

visualvm/core/src/org/graalvm/visualvm/core/datasupport/Stateful.java

@@ -60,6 +60,7 @@ public interface Stateful {
      */
     public int getState();
 
+    public int getModCount();
 
     /**
      * Add a PropertyChangeListener to the listener list.

visualvm/core/src/org/graalvm/visualvm/core/model/ModelCache.java

@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2020, 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package org.graalvm.visualvm.core.model;
+
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Logger;
+import org.graalvm.visualvm.core.datasource.DataSource;
+import org.graalvm.visualvm.core.datasupport.Stateful;
+
+/**
+ *
+ * @author Tomas Hurka
+ */
+final class ModelCache<D extends DataSource, M extends Model> {
+
+    private final static Logger LOGGER = Logger.getLogger(ModelFactory.class.getName());
+
+    /**
+     * special marker for null model
+     */
+    final ModelReference<M> NULL_MODEL;
+    private final Map<DataSourceKey<D>, ModelReference<M>> modelCache;
+
+    ModelCache() {
+        modelCache = Collections.synchronizedMap(new HashMap());
+        NULL_MODEL = new ModelReference(null, 0);
+    }
+
+    Reference<M> get(DataSourceKey<D> key) {
+        ModelReference<M> valueRef = modelCache.get(key);
+        if (valueRef != null && valueRef.modCount != key.modCount) {
+            Reference<M> removed = modelCache.remove(key);
+            LOGGER.finer("Invalid mod count " + key + " " + (removed != null ? "removed" : "not removed"));
+            return null;
+        }
+        return valueRef;
+    }
+
+    Reference<M> put(DataSourceKey<D> key, M value) {
+        ModelReference<M> ref;
+        DataSource ds = key.weakReference.get();
+        if (ds instanceof Stateful && value != null) {
+            ds.addPropertyChangeListener(Stateful.PROPERTY_STATE, new StateListener(key));
+            LOGGER.finer("Registered listener for " + key + " val " + value.getClass());
+        }
+        if (value == null) {
+            ref = NULL_MODEL;
+        } else {
+            ref = new ModelReference(value, key.modCount);
+        }
+        return modelCache.put(key, ref);
+    }
+
+    void clear() {
+        modelCache.clear();
+    }
+
+    /**
+     * DataSource wrapper object, which weakly reference datasource and uses
+     * reference-equality of DataSources when implementing hashCode and equals
+     * this class is used as keys in modelCache
+     */
+    static class DataSourceKey<D extends DataSource> {
+
+        Reference<D> weakReference;
+        int modCount;
+
+        DataSourceKey(D ds) {
+            weakReference = new WeakReference(ds);
+            if (ds instanceof Stateful) {
+                modCount = ((Stateful) ds).getModCount();
+            }
+        }
+
+        public int hashCode() {
+            D ds = weakReference.get();
+            if (ds != null) {
+                return ds.hashCode();
+            }
+            return 0;
+        }
+
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return false;
+            }
+            if (obj instanceof DataSourceKey) {
+                D ds = weakReference.get();
+                D otherDs = ((DataSourceKey<D>) obj).weakReference.get();
+
+                return ds != null && ds == otherDs;
+            }
+            throw new IllegalArgumentException(obj.getClass().getName());
+        }
+
+        public String toString() {
+            DataSource ds = weakReference.get();
+            return "DataSourceKey for " + System.identityHashCode(this) + " for " + ds == null ? "NULL" : ds.toString();    // NOI18N
+        }
+    }
+
+    private static class ModelReference<T> extends SoftReference<T> {
+
+        private int modCount;
+
+        private ModelReference(T ref, int count) {
+            super(ref);
+            modCount = count;
+        }
+    }
+
+    private class StateListener implements PropertyChangeListener {
+
+        DataSourceKey<D> key;
+
+        StateListener(DataSourceKey<D> k) {
+            key = k;
+        }
+
+        @Override
+        public void propertyChange(PropertyChangeEvent evt) {
+            int newState = (Integer) evt.getNewValue();
+            if (newState == Stateful.STATE_AVAILABLE) {
+                DataSource ds = key.weakReference.get();
+                if (ds != null) {
+                    ds.removePropertyChangeListener(Stateful.PROPERTY_STATE, this);
+                }
+                Reference<M> removed = modelCache.remove(key);
+                LOGGER.finer(key + " " + (removed != null ? "removed" : "not removed"));
+            }
+        }
+    }
+}

visualvm/core/src/org/graalvm/visualvm/core/model/ModelFactory.java

@@ -30,18 +30,15 @@
 import org.graalvm.visualvm.core.datasupport.DataChangeListener;
 import org.graalvm.visualvm.core.datasupport.DataChangeSupport;
 import java.lang.ref.Reference;
-import java.lang.ref.SoftReference;
-import java.lang.ref.WeakReference;
 import java.util.Collections;
 import java.util.Comparator;
-import java.util.HashMap;
-import java.util.Map;
 import java.util.SortedSet;
 import java.util.TreeSet;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.logging.Logger;
+import org.graalvm.visualvm.core.model.ModelCache.DataSourceKey;
 
 /**
  * This is abstract factory class for getting model
@@ -58,21 +55,18 @@
 public abstract class ModelFactory<M extends Model,D extends DataSource> {
     final protected static Logger LOGGER = Logger.getLogger(ModelFactory.class.getName());
 
-    /** special marker for null model  */
-    private final Reference<M> NULL_MODEL;
     /** set of registered providers */
     private SortedSet<ModelProvider<M, D>> providers;
     /** providers cannot be changed, when getModel() is running */
     private ReadWriteLock providersLock;
     /** model cache */
-    private Map<DataSourceKey<D>,Reference<M>> modelCache;    
+    private ModelCache<D,M> modelCache;
     /** asynchronous change support */
     private DataChangeSupport<ModelProvider<M, D>> factoryChange;
 
     protected ModelFactory() {
-        NULL_MODEL = new SoftReference(null);
         providers = new TreeSet(new ModelProviderComparator());
-        modelCache = Collections.synchronizedMap(new HashMap());
+        modelCache = new ModelCache();
         factoryChange = new DataChangeSupport();
         providersLock = new ReentrantReadWriteLock();
     }
@@ -98,7 +92,7 @@ public final M getModel(D dataSource) {
                 M model = null;
 
                 if (modelRef != null) {
-                    if (modelRef == NULL_MODEL) {  // cached null model, return null
+                    if (modelRef == modelCache.NULL_MODEL) {  // cached null model, return null
                         return null;
                     }
                     model = modelRef.get(); // if model is in cache return it,
@@ -110,12 +104,12 @@ public final M getModel(D dataSource) {
                 for (ModelProvider<M, D> factory : providers) {
                     model = factory.createModelFor(dataSource);
                     if (model != null) {  // we have model, put it into cache
-                        modelCache.put(key,new SoftReference(model));
+                        modelCache.put(key,model);
                         break;
                     }
                 }
                 if (model == null) {  // model was not found - cache null model
-                    modelCache.put(key,NULL_MODEL);
+                    modelCache.put(key,null);
                 }
                 return model;
             }
@@ -138,7 +132,7 @@ public final boolean registerProvider(ModelProvider<M, D> newProvider) {
             LOGGER.finer("Registering " + newProvider.getClass().getName());    // NOI18N
             boolean added = providers.add(newProvider);
             if (added) {
-                clearCache();
+                modelCache.clear();
                 factoryChange.fireChange(providers,Collections.singleton(newProvider),null);
             }
             return added;
@@ -160,7 +154,7 @@ public final boolean unregisterProvider(ModelProvider<M, D> oldProvider) {
             LOGGER.finer("Unregistering " + oldProvider.getClass().getName());  // NOI18N
             boolean removed = providers.remove(oldProvider);
             if (removed) {
-                clearCache();
+                modelCache.clear();
                 factoryChange.fireChange(providers,null,Collections.singleton(oldProvider));
             }
             return removed;
@@ -169,10 +163,6 @@ public final boolean unregisterProvider(ModelProvider<M, D> oldProvider) {
          }
     }
 
-    public final void clearModel(D dataSource) {
-        modelCache.remove(new DataSourceKey(dataSource));
-    }
-    
     /**
      * Add data change listener. Data change is fired when 
      * {@link ModelProvider} is registered/unregister. 
@@ -202,10 +192,6 @@ public int priority() {
         return -1;
     }
 
-    private void clearCache() {
-        modelCache.clear();
-    }
-    
     /** compare ModelProvider-s using priority. Providers with higher priority
      * gets precedence over those with lower priority
      */
@@ -225,41 +211,4 @@ public int compare(ModelProvider<M, D> provider1, ModelProvider<M, D> provider2)
             return ClassNameComparator.INSTANCE.compare(provider1, provider2);
         }
     }
-    
-    /**
-     * DataSource wrapper object, which weakly reference datasource and uses 
-     *  reference-equality of DataSources when implementing hashCode and equals
-     *  this class is used as keys in modelCache
-     */
-    private static class DataSourceKey<D extends DataSource>  {
-        Reference<D> weakReference;
-        
-        DataSourceKey(D ds) {
-            weakReference = new WeakReference(ds);
-        }
-        
-        public int hashCode() {
-            D ds = weakReference.get();
-            if (ds != null) {
-                return ds.hashCode();
-            }
-            return 0;
-        }
-        
-        public boolean equals(Object obj) {
-            if (obj == null) return false;
-            if (obj instanceof DataSourceKey) {
-                D ds = weakReference.get();
-                D otherDs = ((DataSourceKey<D>)obj).weakReference.get();
-                
-                return ds != null && ds == otherDs;
-            }
-            throw new IllegalArgumentException(obj.getClass().getName());
-        }
-        
-        public String toString() {
-            DataSource ds = weakReference.get();
-            return "DataSourceKey for "+System.identityHashCode(this)+" for "+ds==null?"NULL":ds.toString();    // NOI18N
-        }
-    }
 }

visualvm/host/src/org/graalvm/visualvm/host/Host.java

@@ -51,6 +51,7 @@ public abstract class Host extends DataSource implements Stateful {
     private final String hostName;
     private InetAddress inetAddress;
     private int state = STATE_AVAILABLE;
+    private int modCount;
 
 
     /**
@@ -100,9 +101,16 @@ public synchronized int getState() {
         return state;
     }
 
+    public int getModCount() {
+        return modCount;
+    }
+
     protected final synchronized void setState(int newState) {
         int oldState = state;
         state = newState;
+        if (oldState != newState && newState == STATE_AVAILABLE) {
+            modCount++;
+        }
         getChangeSupport().firePropertyChange(PROPERTY_STATE, oldState, newState);
     }
 

visualvm/jmx/src/org/graalvm/visualvm/jmx/impl/JmxApplicationProvider.java

@@ -380,16 +380,11 @@ public void run() {
                     if (model == null || model.getConnectionState() != JmxModel.ConnectionState.CONNECTED) {
                         synchronized (unavailableApps) { unavailableApps.add(app); }
                     } else {                        
-                        JmxModelFactory.getDefault().clearModel(app);
-                        JvmJvmstatModelFactory.getDefault().clearModel(app);
-                        JvmstatModelFactory.getDefault().clearModel(app);
-                        JvmFactory.getDefault().clearModel(app);
-                        
+                        app.setStateImpl(Stateful.STATE_AVAILABLE);
+
                         model = JmxModelFactory.getJmxModelFor(app);
                         app.jvm = JvmFactory.getJVMFor(app);
 
-                        app.setStateImpl(Stateful.STATE_AVAILABLE);
-                        
                         model.addPropertyChangeListener(new PropertyChangeListener() {
                             public void propertyChange(PropertyChangeEvent evt) {
                                 if (evt.getNewValue() == ConnectionState.CONNECTED) {