Changeset 4086

Timestamp:

Dec 21, 2010, 1:52:03 PM (12 years ago)

Author:

olle

Message:

Refs #668. Class/file plugins/RunMsInspectPlugin.java in plugin/ updated to improve job progress message and percentage information:

1. New private instance variable long inputFileSizeInBytes added, with public accessor methods. It is used to store the size of the input spectrum file in bytes for estimation of fraction of time spent in different process phases. This data is used for progress information.

2. Private method void msInspectSearchLocal(Request request, Response response, ProgressReporter progress, ...) updated to obtain the size of the input spectrum file in bytes and store it in new instance variable inputFileSizeInBytes.

3. Private method void updateProgressInformation(ProgressReporter progress, String line) updated to parse the input string for progress information in the indexing and analysis phases. Calls new private method int EstimatedTotalPercentage(int percentage, boolean isAnalysisPhase) to get the estimated total percentage from percentage values for the two different phases.

4. New private method int EstimatedTotalPercentage(int percentage, boolean isAnalysisPhase) added. It estimates total percentage of time to completion. Assumes two phases, an indexing phase and an analysis phase. Estimates the fraction of time spent in the indexing phase and analysis phase from the size of the input file, based on test runs with input files of different sizes.

File:

• trunk/plugin/src/org/proteios/plugins/RunMsInspectPlugin.java (modified) (6 diffs)

trunk/plugin/src/org/proteios/plugins/RunMsInspectPlugin.java

@@ -224 +224 @@
   private int byteBufferSize = BYTE_BUFFER_SIZE_DEFAULT;
   /*
+   * Size of input file in bytes.
+   */
+  private long inputFileSizeInBytes = 0;
+  /*
    * Flag indicating aborted job.
    */
@@ -250 +254 @@
   {
     this.byteBufferSize = byteBufferSize;
+  }
+
+
+  /**
+   * Get size of input file in bytes.
+   * 
+   * @return long Size of input file in bytes.
+   */
+  public long getInputFileSizeInBytes()
+  {
+    return this.inputFileSizeInBytes;
+  }
+
+
+  /**
+   * Set size of input file in bytes.
+   * 
+   * @param inputFilesizeInBytes long Size of input file in bytes to set.
+   */
+  public void setInputFileSizeInBytes(long inputFileSizeInBytes)
+  {
+    this.inputFileSizeInBytes = inputFileSizeInBytes;
   }
 
@@ -392 +418 @@
     File spectrumFile = factory.getById(File.class, spectrumFileId);
     log.debug("spectrumFile (original) = " + spectrumFile);
+    // Get spectrum file size in bytes for progress calculation
+    long fileSizeInBytes = spectrumFile.getSizeInBytes();
+    setInputFileSizeInBytes(fileSizeInBytes);
     // Always use original spectrum filename, even if a converted file is used for msInspect feature detection
     String originalSpectrumFilename = spectrumFile.getName();
@@ -745 +774 @@
     if (progress != null)
     {
-      if (line.contains("complete"))
-      {
+      if (line.contains("Building index file: "))
+      {
+        // msInspect indexing phase
+        // msInspect typically outputs a line like "16 Dec 2010 11:01:54,145 INFO  ApplicationContext: Building index file: 11%"
+        String testStr = new String("ApplicationContext: ");
+        int index = line.indexOf(testStr);
+        if (index >= 0)
+        {
+          // Cut off start of string including testStr 
+          // Example: indexingMessageStr = "Building index file: 11%"
+          String indexingMessageStr = line.substring(index + testStr.length());
+          /*
+          System.out
+            .println(this.getClass().getSimpleName() + ": indexingMessageStr (1) = \"" + indexingMessageStr + "\"");
+          */
+          testStr = new String("Building index file: ");
+          index = indexingMessageStr.indexOf(testStr);
+          if (index >= 0)
+          {
+            // Cut off start of string including testStr
+            // Example: indexingPercentStr = "11%"
+            String indexingPercentStr = indexingMessageStr.substring(index + testStr.length());
+            testStr = new String("%");
+            index = indexingPercentStr.indexOf(testStr);
+            if (index >= 0)
+            {
+              // Cut off end of string starting with testStr
+              String percentStr = indexingPercentStr.substring(0, index);
+              /*
+              System.out
+                .println(this.getClass().getSimpleName() + ": percentStr (2) = \"" + percentStr + "\"");
+              */
+              // Convert percent string to int
+              int indexingPercentCompleted = 0;
+              try
+              {
+                indexingPercentCompleted = Integer.parseInt(percentStr);
+              }
+              catch (NumberFormatException e)
+              {}
+              // Construct progress message
+              // Example; progressMessage = "Building index file: 11%""
+              String progressMessage = new String(indexingMessageStr);
+              // Total progress includes more than msInspect analysis
+              int percentCompleted = EstimatedTotalPercentage(indexingPercentCompleted, false);
+              if (percentCompleted > 99)
+              {
+                percentCompleted = 99;
+              }
+              progress.display(percentCompleted, progressMessage);
+            }
+          }
+        }
+      }
+      else if (line.contains("complete"))
+      {
+        // msInspect analysis phase
         // msInspect typically outputs a line like "16 Dec 2010 11:02:02,965 INFO  ApplicationContext: 12.043658% complete."
         String testStr = new String("ApplicationContext: ");
@@ -753 +837 @@
         {
           // Cut off start of string including testStr 
-          String percentStr = line.substring(index + testStr.length());
+          // Example: analysisPercentStr = "12.043658% complete."
+          String analysisPercentStr = line.substring(index + testStr.length());
           /*
           System.out
-            .println(this.getClass().getSimpleName() + ": percentStr (1) = \"" + percentStr + "\"");
+            .println(this.getClass().getSimpleName() + ": analysisPercentStr (1) = \"" + analysisPercentStr + "\"");
           */
           testStr = new String(".");
-          index = percentStr.indexOf(testStr);
+          index = analysisPercentStr.indexOf(testStr);
           if (index >= 0)
           {
             // Cut off end of string starting with testStr
-            percentStr = percentStr.substring(0, index);
+            // Example: percentStr = "12"
+            String percentStr = analysisPercentStr.substring(0, index);
             /*
             System.out
@@ -769 +855 @@
             */
             // Convert percent string to int
-            int percentCompleted = 0;
+            int analysisPercentCompleted = 0;
             try
             {
-              percentCompleted = Integer.parseInt(percentStr);
+              analysisPercentCompleted = Integer.parseInt(percentStr);
             }
             catch (NumberFormatException e)
             {}
+            // Construct progress message
+            // Example; progressMessage = "Analysis: 12.043658% complete."
+            String progressMessage = new String("Analysis: " + analysisPercentStr);
             // Total progress includes more than msInspect analysis
+            int percentCompleted = EstimatedTotalPercentage(analysisPercentCompleted, true);
             if (percentCompleted > 99)
             {
               percentCompleted = 99;
             }
-            progress.display(percentCompleted, "% completed");
+            progress.display(percentCompleted, progressMessage);
           }
         }
       }
     }
+  }
+
+
+  /**
+   * Estimates total percentage of time to completion.
+   * Assumes two phases, an indexing phase and an analysis phase.
+   * Estimates the fraction of time spent in the indexing phase
+   * and analysis phase from the size of the input file,
+   * based on test runs with input files of different sizes.
+   * 
+   * @param percentage int Percentage in current phase.
+   * @param isAnalysisPhase boolean Flag indication if process is in analysis phase.
+   * @return int The estimated total percentage of time to completion.
+   */
+  private int EstimatedTotalPercentage(int percentage, boolean isAnalysisPhase)
+  {
+    // Get input file size in bytes for progress calculation
+    long fileSizeInBytes = getInputFileSizeInBytes();
+    double analysisIndexingRatio = ((double) fileSizeInBytes)/(1024.0*1024.0) * 0.066;
+    if (analysisIndexingRatio < 1.0)
+    {
+      analysisIndexingRatio = 1.0;
+    }
+    double phaseFraction = ((double) percentage)/100.0;
+    if (phaseFraction > 1.0)
+    {
+      phaseFraction = 1.0;
+    }
+    double totalFraction = phaseFraction/(1.0 + analysisIndexingRatio);
+    if (isAnalysisPhase)
+    {
+      totalFraction = (1.0 + phaseFraction*analysisIndexingRatio)/(1.0 + analysisIndexingRatio);
+    }
+    if (totalFraction > 1.0)
+    {
+      totalFraction = 1.0;
+    }
+    double totalPercentage = 100.0*totalFraction;
+    int totalIntegerPercentage = (int) totalPercentage;
+    System.out.println(this.getClass().getSimpleName() + ": percentage = " + percentage + " isAnalysisPhase = " + isAnalysisPhase + " fileSizeInBytes = " + fileSizeInBytes + " analysisIndexingRatio = " + analysisIndexingRatio + " totalPercentage = " + totalPercentage + " totalIntegerPercentage = " + totalIntegerPercentage);
+    return totalIntegerPercentage;
   }