Changeset 1510 for branches/eraser6/SpeedMeter/Eraser.Manager/ProgressManager.cs

Timestamp:

1/12/2010 8:05:29 AM (3 years ago)

Author:

lowjoel

Message:

Thread-safe the ChainedProgressManager? classes by locking the task list before modifying or accessing them. This may introduce lock contention performance penalties but we'll stick with this first (fix it with a writer lock afterward if it turns out to be a performance bottleneck.) The ProgressManager? class is not locked at all since it deals with integers only.

File:

• branches/eraser6/SpeedMeter/Eraser.Manager/ProgressManager.cs (modified) (22 diffs)

branches/eraser6/SpeedMeter/Eraser.Manager/ProgressManager.cs

@@ -262 +262 @@
             {
                 List = new List<Step>();
+                ListLock = manager.ListLock;
                 Manager = manager;
             }
@@ -269 +270 @@
             public int IndexOf(Step item)
             {
-                return List.IndexOf(item);
+                lock (ListLock)
+                    return List.IndexOf(item);
             }
 
             public void Insert(int index, Step item)
             {
-                List.Insert(index, item);
-                TotalWeights += item.Weight;
+                lock (ListLock)
+                {
+                    List.Insert(index, item);
+                    TotalWeights += item.Weight;
+                }
             }
 
             public void RemoveAt(int index)
             {
-                TotalWeights -= List[index].Weight;
-                List.RemoveAt(index);
+                lock (ListLock)
+                {
+                    TotalWeights -= List[index].Weight;
+                    List.RemoveAt(index);
+                }
             }
 
@@ -288 +296 @@
                 get
                 {
-                    return List[index];
+                    lock (ListLock)
+                        return List[index];
                 }
                 set
                 {
-                    TotalWeights -= List[index].Weight;
-                    List[index] = value;
-                    TotalWeights += value.Weight;
+                    lock (ListLock)
+                    {
+                        TotalWeights -= List[index].Weight;
+                        List[index] = value;
+                        TotalWeights += value.Weight;
+                    }
                 }
             }
@@ -304 +316 @@
             public void Add(Step item)
             {
-                List.Add(item);
-                TotalWeights += item.Weight;
+                lock (ListLock)
+                {
+                    List.Add(item);
+                    TotalWeights += item.Weight;
+                }
             }
 
             public void Clear()
             {
-                List.Clear();
-                TotalWeights = 0;
+                lock (ListLock)
+                {
+                    List.Clear();
+                    TotalWeights = 0;
+                }
             }
 
             public bool Contains(Step item)
             {
-                return List.Contains(item);
+                lock (ListLock)
+                    return List.Contains(item);
             }
 
             public void CopyTo(Step[] array, int arrayIndex)
             {
-                List.CopyTo(array, arrayIndex);
+                lock (ListLock)
+                    List.CopyTo(array, arrayIndex);
             }
 
             public int Count
             {
-                get { return List.Count; }
+                get
+                {
+                    lock (ListLock) 
+                        return List.Count;
+                }
             }
 
@@ -366 +390 @@
             /// The total weights of all the steps.
             /// </summary>
-            public float TotalWeights
+            private float TotalWeights
             {
                 get
@@ -372 +396 @@
                     return totalWeights;
                 }
-                private set
+                set
                 {
                     if (value >= 1.1f || value < 0.0f)
@@ -388 +412 @@
 
             /// <summary>
+            /// The lock object guarding the list against parallel writes.
+            /// </summary>
+            private object ListLock;
+
+            /// <summary>
             /// The <see cref="SteppedProgressManager"/> instance which owns this list.
             /// </summary>
@@ -404 +433 @@
         {
             Steps = new StepsList(this);
+            ListLock = new object();
         }
 
@@ -411 +441 @@
             {
                 float result = 0.0f;
-                foreach (Step step in Steps)
-                    result += step.Progress.Progress * step.Weight;
+                lock (ListLock)
+                    foreach (Step step in Steps)
+                        result += step.Progress.Progress * step.Weight;
 
                 return result;
@@ -457 +488 @@
             get
             {
-                if (Steps.Count == 0)
-                    return null;
-
-                foreach (Step step in Steps)
-                    if (step.Progress.Progress < 1.0f)
-                        return step;
-
-                //Return the last step since we don't have any
-                return Steps[Steps.Count - 1];
-            }
-        }
+                lock (ListLock)
+                {
+                    if (Steps.Count == 0)
+                        return null;
+
+                    foreach (Step step in Steps)
+                        if (step.Progress.Progress < 1.0f)
+                            return step;
+
+                    //Return the last step since we don't have any
+                    return Steps[Steps.Count - 1];
+                }
+            }
+        }
+
+        /// <summary>
+        /// The lock object guarding the list of steps against concurrent read and write.
+        /// </summary>
+        private object ListLock;
     }
 
@@ -481 +520 @@
         public class SubTasksList : IList<ProgressManagerBase>
         {
-            public SubTasksList()
+            public SubTasksList(ParallelProgressManager manager)
             {
                 List = new List<ProgressManagerBase>();
+                ListLock = manager.TaskLock;
             }
 
@@ -490 +530 @@
             public int IndexOf(ProgressManagerBase item)
             {
-                return List.IndexOf(item);
+                lock (ListLock)
+                    return List.IndexOf(item);
             }
 
             public void Insert(int index, ProgressManagerBase item)
             {
-                List.Insert(index, item);
+                lock (ListLock)
+                    List.Insert(index, item);
             }
 
             public void RemoveAt(int index)
             {
-                List.RemoveAt(index);
+                lock (ListLock)
+                    List.RemoveAt(index);
             }
 
@@ -507 +550 @@
                 get
                 {
-                    return List[index];
+                    lock (ListLock)
+                        return List[index];
                 }
                 set
                 {
-                    List[index] = value;
+                    lock (ListLock)
+                        List[index] = value;
                 }
             }
@@ -521 +566 @@
             public void Add(ProgressManagerBase item)
             {
-                List.Add(item);
+                lock (ListLock)
+                    List.Add(item);
             }
 
             public void Clear()
             {
-                List.Clear();
+                lock (ListLock)
+                    List.Clear();
             }
 
@@ -536 +583 @@
             public void CopyTo(ProgressManagerBase[] array, int arrayIndex)
             {
-                List.CopyTo(array, arrayIndex);
+                lock (ListLock)
+                    List.CopyTo(array, arrayIndex);
             }
 
             public int Count
             {
-                get { return List.Count; }
+                get
+                {
+                    lock (ListLock) 
+                        return List.Count;
+                }
             }
 
@@ -551 +603 @@
             public bool Remove(ProgressManagerBase item)
             {
-                return List.Remove(item);
+                lock (ListLock)
+                    return List.Remove(item);
             }
 
@@ -580 +633 @@
 
             /// <summary>
-            /// The total weights of all the steps.
-            /// </summary>
-            public int TotalWeights
-            {
-                get;
-                private set;
-            }
+            /// The lock object guarding the list from concurrent read/writes.
+            /// </summary>
+            private object ListLock;
         }
 
@@ -594 +643 @@
         public ParallelProgressManager()
         {
-            Tasks = new SubTasksList();
+            Tasks = new SubTasksList(this);
+            TaskLock = new object();
         }
 
@@ -602 +652 @@
             {
                 float result = 0.0f;
-                foreach (ProgressManagerBase subTask in Tasks)
-                    result += subTask.Progress * (1.0f / Tasks.Count);
+                lock (TaskLock)
+                    foreach (ProgressManagerBase subTask in Tasks)
+                        result += subTask.Progress * (1.0f / Tasks.Count);
 
                 return result;
@@ -614 +665 @@
             {
                 int maxSpeed = 0;
-                foreach (ProgressManagerBase subTask in Tasks)
-                    maxSpeed = Math.Max(subTask.Speed, maxSpeed);
+                lock (TaskLock)
+                    foreach (ProgressManagerBase subTask in Tasks)
+                        maxSpeed = Math.Max(subTask.Speed, maxSpeed);
 
                 return maxSpeed;
@@ -626 +678 @@
             {
                 TimeSpan maxTime = TimeSpan.MinValue;
-                foreach (ProgressManagerBase subTask in Tasks)
-                    if (maxTime < subTask.TimeLeft)
-                        maxTime = subTask.TimeLeft;
+                lock (TaskLock)
+                    foreach (ProgressManagerBase subTask in Tasks)
+                        if (maxTime < subTask.TimeLeft)
+                            maxTime = subTask.TimeLeft;
 
                 return maxTime;
@@ -643 +696 @@
             private set;
         }
+
+        /// <summary>
+        /// The lock object guarding the list of tasks against concurrent read and write.
+        /// </summary>
+        private object TaskLock;
     }
 }