vtk/src/vtk/vtkJavaMemoryManagerImpl.java

   1 package vtk;
   2
   3 import java.lang.ref.WeakReference;
   4 import java.lang.reflect.Constructor;
   5 import java.util.HashMap;
   6 import java.util.TreeSet;
   7 import java.util.concurrent.locks.ReentrantLock;
   8
   9 /**
  10  * Provide a Java thread safe implementation of vtkJavaMemoryManager. This does
  11  * not make VTK thread safe. This only insure that the change of reference count
  12  * will never happen in two concurrent thread in the Java world.
  13  *
  14  * @see vtkJavaMemoryManager
  15  * @author sebastien jourdain - sebastien.jourdain@kitware.com
  16  */
  17 public class vtkJavaMemoryManagerImpl implements vtkJavaMemoryManager {
  18     private vtkJavaGarbageCollector garbageCollector;
  19     private ReentrantLock lock;
  20     private vtkReferenceInformation lastGcResult;
  21     private HashMap<Long, WeakReference<vtkObjectBase>> objectMap;
  22     private HashMap<Long, String> objectMapClassName;
  23
  24     public vtkJavaMemoryManagerImpl() {
  25         this.lock = new ReentrantLock();
  26         this.objectMap = new HashMap<Long, WeakReference<vtkObjectBase>>();
  27         this.objectMapClassName = new HashMap<Long, String>();
  28         this.garbageCollector = new vtkJavaGarbageCollector();
  29     }
  30
  31     // Thread safe
  32     public vtkObjectBase getJavaObject(Long vtkId) {
  33         // Check pre-condition
  34         if (vtkId == null || vtkId.longValue() == 0) {
  35             throw new RuntimeException("Invalid ID, can not be null or equal to 0.");
  36         }
  37
  38         // Check inside the map if the object is already there
  39         WeakReference<vtkObjectBase> value = objectMap.get(vtkId);
  40         vtkObjectBase resultObject = (value == null) ? null : value.get();
  41
  42         // If not, we have to do something
  43         if (value == null || resultObject == null) {
  44             try {
  45                 // Make sure no concurrency could happen inside that
  46                 this.lock.lock();
  47
  48                 // Now that we have the lock make sure someone else didn't
  49                 // create the object in between, if so just return the created
  50                 // instance
  51                 value = objectMap.get(vtkId);
  52                 resultObject = (value == null) ? null : value.get();
  53                 if (resultObject != null) {
  54                     return resultObject;
  55                 }
  56
  57                 // We need to do the work of the gc
  58                 if (value != null && resultObject == null) {
  59                     this.unRegisterJavaObject(vtkId);
  60                 }
  61
  62                 // No-one did create it, so let's do it
  63                 if (resultObject == null) {
  64                     try {
  65                         String className = vtkObjectBase.VTKGetClassNameFromReference(vtkId.longValue());
  66                         Class c = Class.forName("vtk." + className);
  67                         Constructor cons = c.getConstructor(new Class[] { long.class });
  68                         resultObject = (vtkObjectBase) cons.newInstance(new Object[] { vtkId });
  69                     } catch (Exception e) {
  70                         e.printStackTrace();
  71                     }
  72                 }
  73             } finally {
  74                 this.lock.unlock();
  75             }
  76         }
  77         return resultObject;
  78     }
  79
  80     // Thread safe
  81     public void registerJavaObject(Long id, vtkObjectBase obj) {
  82         try {
  83             this.lock.lock();
  84             this.objectMap.put(id, new WeakReference<vtkObjectBase>(obj));
  85             this.objectMapClassName.put(id, obj.GetClassName());
  86         } finally {
  87             this.lock.unlock();
  88         }
  89     }
  90
  91     // Thread safe
  92     public void unRegisterJavaObject(Long id) {
  93         try {
  94             this.lock.lock();
  95             this.objectMapClassName.remove(id);
  96             WeakReference<vtkObjectBase> value = this.objectMap.remove(id);
  97
  98             // Prevent double deletion...
  99             if (value != null) {
 100                 vtkObjectBase.VTKDeleteReference(id.longValue());
 101             } else {
 102                 throw new RuntimeException("You try to delete a vtkObject that is not referenced in the Java object Map. You may have call Delete() twice.");
 103             }
 104         } finally {
 105             this.lock.unlock();
 106         }
 107     }
 108
 109     // Thread safe
 110     public vtkReferenceInformation gc(boolean debug) {
 111         System.gc();
 112         try {
 113             this.lock.lock();
 114             final vtkReferenceInformation infos = new vtkReferenceInformation(debug);
 115             for (Long id : new TreeSet<Long>(this.objectMap.keySet())) {
 116                 vtkObjectBase obj = this.objectMap.get(id).get();
 117                 if (obj == null) {
 118                     infos.addFreeObject(this.objectMapClassName.get(id));
 119                     this.unRegisterJavaObject(id);
 120                 } else {
 121                     infos.addKeptObject(this.objectMapClassName.get(id));
 122                 }
 123             }
 124
 125             this.lastGcResult = infos;
 126             return infos;
 127         } finally {
 128             this.lock.unlock();
 129         }
 130     }
 131
 132     public vtkJavaGarbageCollector getAutoGarbageCollector() {
 133         return this.garbageCollector;
 134     }
 135
 136     // Thread safe
 137     public int deleteAll() {
 138         int size = this.objectMap.size();
 139         try {
 140             this.lock.lock();
 141             for (Long id : new TreeSet<Long>(this.objectMap.keySet())) {
 142                 this.unRegisterJavaObject(id);
 143             }
 144         } finally {
 145             this.lock.unlock();
 146         }
 147         return size;
 148     }
 149
 150     public int getSize() {
 151         return objectMap.size();
 152     }
 153
 154     public vtkReferenceInformation getLastReferenceInformation() {
 155         return this.lastGcResult;
 156     }
 157 }