Changeset 1972 for trunk/eraser

Timestamp:

4/28/2010 6:32:03 AM (3 years ago)

Author:

lowjoel

Message:

Added code which computes prediction intervals to better deal with fluctuations in erase speeds.

Location:

trunk/eraser

Files:

• Dependencies/alglib.dll (added)
• Dependencies/alglib.pdb (added)
• Eraser.Util/Eraser.Util.csproj (modified) (2 diffs)
• Eraser.Util/ProgressManager.cs (modified) (5 diffs)
• Eraser.Util/Sampler.cs (added)
• Installer/DirectoryStructure.wxs (modified) (1 diff)

trunk/eraser/Eraser.Util/Eraser.Util.csproj

@@ -50 +50 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="alglib, Version=2.3.0.0, Culture=neutral, PublicKeyToken=3ac89a0351e689b6, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\Dependencies\alglib.dll</HintPath>
+    </Reference>
     <Reference Include="CommonLibrary, Version=0.9.3.10, Culture=neutral, PublicKeyToken=3ac89a0351e689b6, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -114 +118 @@
     <Compile Include="NativeMethods\Sfc.cs" />
     <Compile Include="ProgressManager.cs" />
+    <Compile Include="Sampler.cs" />
     <Compile Include="ExtensionClasses\SharingViolationException.cs" />
     <Compile Include="Shell.cs" />

trunk/eraser/Eraser.Util/ProgressManager.cs

@@ -51 +51 @@
         {
             StartTime = DateTime.Now;
+            lock (Speeds)
+                Speeds.Reset();
         }
 
@@ -87 +89 @@
             private set;
         }
+
+        /// <summary>
+        /// Samples the current speed of the task.
+        /// </summary>
+        /// <param name="speed">The speed of the task.</param>
+        protected void SampleSpeed(float speed)
+        {
+            lock (Speeds)
+            {
+                IList<KeyValuePair<DateTime, double>> outliers = Speeds.GetOutliers(0.95);
+                if (outliers != null)
+                {
+                    List<KeyValuePair<DateTime, double>> recentOutliers = outliers.Where(
+                        sample => (DateTime.Now - sample.Key).TotalSeconds <= 60).ToList();
+                    if (recentOutliers.Count >= 5)
+                    {
+                        Speeds.Reset();
+                        recentOutliers.ForEach(sample => Speeds.Add(sample.Value));
+                    }
+                }
+
+                Speeds.Add(speed);
+                PredictedSpeed = Speeds.Predict(0.95);
+            }
+        }
+
+        /// <summary>
+        /// Predicts the speed of the operation, given the current samples.
+        /// </summary>
+        protected Interval PredictedSpeed
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// The speed sampler.
+        /// </summary>
+        private Sampler Speeds = new Sampler();
     }
 
@@ -170 +211 @@
 
                 //Then compute the speed of the calculation
-                lastSpeed = (float)((Completed - lastCompleted) / timeElapsed / total);
+                long progressDelta = Completed - lastCompleted;
+                float currentSpeed = (float)(progressDelta / timeElapsed / total);
                 lastSpeedCalc = DateTime.Now;
                 lastCompleted = Completed;
+
+                //We won't update the speed of the task if the current speed is within
+                //the lower and upper prediction interval.
+                Interval interval = PredictedSpeed;
+                if (interval != null)
+                {
+                    if (currentSpeed < interval.Minimum)
+                    {
+                        Restart();
+                        lastSpeed = currentSpeed;
+                    }
+                    else if (currentSpeed > interval.Maximum)
+                    {
+                        Restart();
+                        lastSpeed = currentSpeed;
+                    }
+                    else if (lastSpeed == 0.0f)
+                    {
+                        lastSpeed = currentSpeed;
+                    }
+                }
+
+                SampleSpeed(currentSpeed);
                 return lastSpeed;
             }
@@ -421 +486 @@
             get
             {
-                if (CurrentStep == null)
-                    return 0;
-
-                return CurrentStep.Progress.Speed;
+                if ((DateTime.Now - lastSpeedCalc).TotalSeconds < SpeedCalcInterval)
+                    return lastSpeed;
+
+                //Calculate how much time has passed
+                double timeElapsed = (DateTime.Now - lastSpeedCalc).TotalSeconds;
+
+                //Then compute the speed of the calculation
+                float currentProgress = Progress;
+                float progressDelta = currentProgress - lastCompleted;
+                float currentSpeed = (float)(progressDelta / timeElapsed);
+                lastSpeedCalc = DateTime.Now;
+                lastCompleted = Progress;
+
+                //If the progress delta is zero, it usually means that the amount
+                //completed within the calculatin interval is too short -- lengthen
+                //the interval so we can get a small difference, significant to make
+                //a speed calculation. Likewise, if it is too great a difference,
+                //we need to shorten the interval to get more accurate calculations
+                if (progressDelta == 0.0)
+                    SpeedCalcInterval *= 2;
+                else if (progressDelta > 3.0)
+                    SpeedCalcInterval -= 3;
+
+                //We won't update the speed of the task if the current speed is within
+                //the lower and upper prediction interval.
+                Interval interval = PredictedSpeed;
+                if (interval != null)
+                {
+                    if (currentSpeed < interval.Minimum)
+                    {
+                        Restart();
+                        lastSpeed = currentSpeed;
+                    }
+                    else if (currentSpeed > interval.Maximum)
+                    {
+                        Restart();
+                        lastSpeed = currentSpeed;
+                    }
+                    else if (lastSpeed == 0.0f)
+                    {
+                        lastSpeed = currentSpeed;
+                    }
+                }
+
+                SampleSpeed(currentSpeed);
+                return lastSpeed;
             }
         }
@@ -487 +594 @@
         /// </summary>
         private object ListLock;
+
+        /// <summary>
+        /// The amount of time elapsed before a new speed calculation is made.
+        /// </summary>
+        private int SpeedCalcInterval = 15;
+
+        /// <summary>
+        /// The last time a speed calculation was computed so that speed is not
+        /// computed too often.
+        /// </summary>
+        private DateTime lastSpeedCalc;
+
+        /// <summary>
+        /// The amount of the operation completed at the last speed computation.
+        /// </summary>
+        private float lastCompleted;
+
+        /// <summary>
+        /// The last calculated speed of the operation.
+        /// </summary>
+        private float lastSpeed;
     }
 

trunk/eraser/Installer/DirectoryStructure.wxs

@@ -55 +55 @@
                         Type="string" Value="[!EraserExe]" />
 
+                    <File Id="Alglib" Name="alglib.dll" Source="..\bin\Release\alglib.dll"
+                        ProcessorArchitecture="msil" />
                     <File Id="BevelLine" Name="BevelLine.dll" Source="..\bin\Release\BevelLine.dll"
                         ProcessorArchitecture="msil" />