// KeepResidentPlugin.java, created Aug 14, 2004 1:20:44 AM by joewhaley
   // Copyright (C) 2004 John Whaley <jwhaley@alum.mit.edu>
   // Licensed under the terms of the CPL; see LICENSE.txt for details.
   package edu.stanford.suif.keepresident;
   
   import java.util.MissingResourceException;
   import java.util.ResourceBundle;
   import java.io.IOException;
   import org.eclipse.core.runtime.IPluginDescriptor;
  import org.eclipse.jface.dialogs.MessageDialog;
  import org.eclipse.jface.preference.IPersistentPreferenceStore;
  import org.eclipse.jface.preference.IPreferenceStore;
  import org.eclipse.swt.widgets.Shell;
  import org.eclipse.ui.IStartup;
  import org.eclipse.ui.plugin.AbstractUIPlugin;
  import org.osgi.framework.BundleContext;
  import edu.stanford.suif.keepresident.preferences.KeepResidentPreferencePage;
  
  /***
   * The main plugin class to be used in the desktop.
   */
  public class KeepResidentPlugin extends AbstractUIPlugin implements IStartup {
      //The shared instance.
      private static KeepResidentPlugin plugin;
      //Resource bundle.
      private ResourceBundle resourceBundle;
  
      KernelInterface i;
      WindowsHeap heap;
      int hardMinimum, hardMaximum;
      int currentMinimum, currentMaximum;
      int pageSize;
      
      public int getHardMinimum() {
          return hardMinimum;
      }
      public int getHardMaximum() {
          return hardMaximum;
      }
      public int getLockedBytes() {
          return heap.getLockedBytes();
      }
  
      private void initialize() {
          i = new KernelInterface();
          heap = new WindowsHeap(i);
          int[] sSysInfo = new int[256];
          int pSysInfo = KernelInterface.GetIntArrayElements(sSysInfo);
          i.call("GetSystemInfo", pSysInfo);
          KernelInterface.ReleaseIntArrayElements(sSysInfo, pSysInfo);
          pageSize = sSysInfo[1];
  
          int pMemoryStatus = KernelInterface.GetIntArrayElements(sSysInfo);
          i.call("GlobalMemoryStatus", pMemoryStatus);
          KernelInterface.ReleaseIntArrayElements(sSysInfo, pMemoryStatus);
          int totalPhysical = sSysInfo[2];
          if (totalPhysical < 0) totalPhysical = Integer.MAX_VALUE;
          
          hardMinimum = 20 * pageSize;
          hardMaximum = totalPhysical - 512 * pageSize;
          
          //System.out.println("Page size="+pageSize+", total physical="+totalPhysical);
          //System.out.println("Minimum="+hardMinimum+", maximum="+hardMaximum);
          
      }
      
      private void setDefaults() {
          IPreferenceStore store = getPreferenceStore();
          // cannot use defaults due to eclipse stupidity!
          // this doesn't seem to work when called from earlyStartup().
          // any value which is the same as default is not saved in the preference store.
          store.setDefault(KeepResidentPreferencePage.P_MIN, 100000000);
          store.setDefault(KeepResidentPreferencePage.P_MAX, 500000000);
          store.setDefault(KeepResidentPreferencePage.P_LOCK, true);
      }
      
      /***
       * The constructor.
       */
      //public KeepResidentPlugin() {
      public KeepResidentPlugin(IPluginDescriptor d) {
          //super();
          super(d);
          plugin = this;
          try {
              resourceBundle = ResourceBundle
                  .getBundle("edu.stanford.suif.keepresident.KeepResidentPluginResources");
          } catch (MissingResourceException x) {
              resourceBundle = null;
          }
          try {
              initialize();
          } catch (KernelException x) {
              MessageDialog.openInformation(new Shell(),
                  "KeepResident Plug-in", x.getMessage());
          }
      }
  
      public void updateProcessWorkingSetSize() {
         int proc = i.call("GetCurrentProcess");
         int[] a = new int[1];
         int[] b = new int[1];
         int pa = KernelInterface.GetIntArrayElements(a);
         int pb = KernelInterface.GetIntArrayElements(b);
         i.call_nz("GetProcessWorkingSetSize", proc, pa, pb);
         KernelInterface.ReleaseIntArrayElements(b, pb);
         KernelInterface.ReleaseIntArrayElements(a, pa);
         currentMinimum = a[0];
         currentMaximum = b[0];
         //System.out.println("Process working set size: "+currentMinimum+", "+currentMaximum);
         IPreferenceStore store = getPreferenceStore();
         store.setValue(KeepResidentPreferencePage.P_MIN, currentMinimum);
         store.setValue(KeepResidentPreferencePage.P_MAX, currentMaximum);
     }
     
     public int TECHNIQUE = 2;
     
     public void setProcessWorkingSetSize(int min, int max, boolean useVirtualLock) {
         int proc = i.call("GetCurrentProcess");
         
         // First, release all locks on memory so that it is possible to shrink
         // working set size.
         heap.releaseAllLocks();
         
         // Set the process working set size.
         System.out.println("Setting process working set size to "+min+", "+max);
         i.call_nz("SetProcessWorkingSetSize", proc, min, max);
         
         if (useVirtualLock) {
             {
                 // Use of VirtualLock is potentially unstable, so temporarily disable the
                 // preference setting so if it *does* crash, we won't try it again.
                 IPreferenceStore store = getPreferenceStore();
                 store.setValue(KeepResidentPreferencePage.P_LOCK, false);
                 try {
                     ((IPersistentPreferenceStore) store).save();
                 } catch (IOException x) {
                 }
             }
             
             int lockedBytes;
             // lockAllVM seems to work much better than lockAllHeaps,
             // and lockAllMemory seems to sometimes be unstable on some systems.
             switch (TECHNIQUE) {
             case 1:
                 lockedBytes = heap.lockAllHeaps(pageSize);
                 break;
             case 2:
                 lockedBytes = heap.lockAllVM();
                 break;
             case 3:
                 int minAddr = WindowsHeap.SystemInfo[WindowsHeap.lpMinimumApplicationAddress];
                 int maxAddr = WindowsHeap.SystemInfo[WindowsHeap.lpMaximumApplicationAddress];
                 lockedBytes = heap.lockAllMemory(minAddr, maxAddr, pageSize);
                 break;
             default:
                 throw new IllegalArgumentException("Unknown technique "+TECHNIQUE);
             }
             System.out.println(lockedBytes+" bytes locked.");
             
             {
                 // Locking was successful: re-enable the flag.
                 IPreferenceStore store = getPreferenceStore();
                 store.setValue(KeepResidentPreferencePage.P_LOCK, true);
                 // Now if Eclipse exits normally, it will automatically
                 // save the flag in the preferences.
             }
         }
         updateProcessWorkingSetSize();
     }
     
     /***
      * Update.
      */
     public void update() {
         IPreferenceStore store = getPreferenceStore();
         int min = store.getInt(KeepResidentPreferencePage.P_MIN);
         int max = store.getInt(KeepResidentPreferencePage.P_MAX);
         boolean b = store.getBoolean(KeepResidentPreferencePage.P_LOCK);
         if (min != 0 && max != 0) {
             min = Math.max(min, hardMinimum);
             max = Math.min(max, hardMaximum);
             min = Math.min(min, max);
             setProcessWorkingSetSize(min, max, b);
         }
     }
     
     /***
      * This method is called upon plug-in activation
      */
     public void start(BundleContext context) throws Exception {
         super.start(context);
     }
 
     /***
      * This method is called when the plug-in is stopped
      */
     public void stop(BundleContext context) throws Exception {
         super.stop(context);
     }
 
     /***
      * Returns the shared instance.
      */
     public static KeepResidentPlugin getDefault() {
         return plugin;
     }
 
     /***
      * Returns the string from the plugin's resource bundle, or 'key' if not
      * found.
      */
     public static String getResourceString(String key) {
         ResourceBundle bundle = KeepResidentPlugin.getDefault()
             .getResourceBundle();
         try {
             return (bundle != null) ? bundle.getString(key) : key;
         } catch (MissingResourceException e) {
             return key;
         }
     }
 
     /***
      * Returns the plugin's resource bundle,
      */
     public ResourceBundle getResourceBundle() {
         return resourceBundle;
     }
     
     /* (non-Javadoc)
      * @see org.eclipse.ui.IStartup#earlyStartup()
      */
     public void earlyStartup() {
         try {
             update();
         } catch (KernelException x) {
             MessageDialog.openInformation(new Shell(),
                 "KeepResident Plug-in", x.getMessage());
         }
     }
     
 }