Directory cleanup for System.Collections.Concurrent partitioners

diff --git a/mcs/class/System.Core/System.Linq.Parallel/ParallelPartitioner.cs b/mcs/class/System.Core/System.Linq.Parallel/ParallelPartitioner.cs
index 8f182f288a2b5adfd28c8aa69e4d70ef84ee0ff2..e9bf2f8b4e2b3c127dd38d3670d47d3336a80b96 100644 (file)
--- a/mcs/class/System.Core/System.Linq.Parallel/ParallelPartitioner.cs
+++ b/mcs/class/System.Core/System.Linq.Parallel/ParallelPartitioner.cs
@@ -24,11 +24,12 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+#if NET_4_0
+
 using System;
 using System.Collections.Generic;
 using System.Collections.Concurrent;
-
-#if NET_4_0
+using System.Collections.Concurrent.Partitioners;
 
 namespace System.Linq.Parallel
 {

diff --git a/mcs/class/System.Core/net_4_0_System.Core.dll.sources b/mcs/class/System.Core/net_4_0_System.Core.dll.sources
index 7337e4eb011303b8fc4626197130e5a0b069eea8..4ed0924d7fef54de591d32908f2c51a06773029c 100644 (file)
--- a/mcs/class/System.Core/net_4_0_System.Core.dll.sources
+++ b/mcs/class/System.Core/net_4_0_System.Core.dll.sources
@@ -257,6 +257,6 @@ System.Linq.Parallel/IVisitableNode.cs
 System.Linq.Parallel/QueryCheckerVisitor.cs
 System.Linq.Parallel/QueryIsOrderedVisitor.cs
 System.Linq.Parallel/QueryOptions.cs
-../corlib/System.Collections.Concurrent/Partitioners/EnumerablePartitioner.cs
+../corlib/System.Collections.Concurrent.Partitioners/EnumerablePartitioner.cs
 ../corlib/System.Collections.Concurrent/ConcurrentSkipList.cs
 ../corlib/System.Threading/AtomicBoolean.cs

diff --git a/mcs/class/corlib/System.Collections.Concurrent.Partitioners/ChangeLog b/mcs/class/corlib/System.Collections.Concurrent.Partitioners/ChangeLog
new file mode 100644 (file)
index 0000000..12789a4
--- /dev/null
+++ b/mcs/class/corlib/System.Collections.Concurrent.Partitioners/ChangeLog
@@ -0,0 +1,8 @@
+2010-04-15  Jérémie Laval  <jeremie.laval@gmail.com>
+
+       * ListPartitioner.cs: Remove playground code
+
+2010-04-15  Jérémie Laval  <jeremie.laval@gmail.com>
+
+       * ListPartitioner.cs:
+       * EnumerablePartitioner.cs: Add internal behavior specific to PLinq

diff --git a/mcs/class/corlib/System.Collections.Concurrent.Partitioners/EnumerablePartitioner.cs b/mcs/class/corlib/System.Collections.Concurrent.Partitioners/EnumerablePartitioner.cs
new file mode 100644 (file)
index 0000000..84b4466
--- /dev/null
+++ b/mcs/class/corlib/System.Collections.Concurrent.Partitioners/EnumerablePartitioner.cs
@@ -0,0 +1,116 @@
+// 
+// EnumerablePartitioner.cs
+//  
+// Author:
+//       Jérémie "Garuma" Laval <jeremie.laval@gmail.com>
+// 
+// Copyright (c) 2009 Jérémie "Garuma" Laval
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#if NET_4_0 || BOOTSTRAP_NET_4_0
+
+using System;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+
+namespace System.Collections.Concurrent.Partitioners
+{
+       // Represent a chunk partitioner
+       internal class EnumerablePartitioner<T> : OrderablePartitioner<T>
+       {
+               IEnumerable<T> source;
+               
+               const int InitialPartitionSize = 1;
+               const int PartitionMultiplier = 2;
+               
+               int initialPartitionSize;
+               int partitionMultiplier;
+               
+               int index = 0;
+               readonly object syncLock = new object ();
+               
+               public EnumerablePartitioner (IEnumerable<T> source)
+                       : this (source, InitialPartitionSize, PartitionMultiplier)
+               {
+
+               }
+               
+               // This is used to get striped partitionning (for Take and Skip for instance
+               public EnumerablePartitioner (IEnumerable<T> source, int initialPartitionSize, int partitionMultiplier)
+                        : base (true, false, true)
+               {
+                       this.source = source;
+                       this.initialPartitionSize = initialPartitionSize;
+                       this.partitionMultiplier = partitionMultiplier;
+               }
+               
+               public override IList<IEnumerator<KeyValuePair<long, T>>> GetOrderablePartitions (int partitionCount)
+               {
+                       if (partitionCount <= 0)
+                               throw new ArgumentOutOfRangeException ("partitionCount");
+                       
+                       IEnumerator<KeyValuePair<long, T>>[] enumerators
+                               = new IEnumerator<KeyValuePair<long, T>>[partitionCount];
+                       
+                       IEnumerator<T> src = source.GetEnumerator ();
+                       
+                       for (int i = 0; i < enumerators.Length; i++) {
+                               enumerators[i] = GetPartitionEnumerator (src);
+                       }
+                       
+                       return enumerators;
+               }
+               
+               IEnumerator<KeyValuePair<long, T>> GetPartitionEnumerator (IEnumerator<T> src)
+               {
+                       int count = initialPartitionSize;
+                       List<T> list = new List<T> ();
+                       
+                       while (true) {
+                               list.Clear ();
+                               int ind = -1;
+                               
+                               lock (syncLock) {
+                                       ind = index;
+                                       
+                                       for (int i = 0; i < count; i++) {
+                                               if (!src.MoveNext ()) {
+                                                       if (list.Count == 0)
+                                                               yield break;
+                                                       else
+                                                               break;
+                                               }
+                                               
+                                               list.Add (src.Current);
+                                               index++;
+                                       }                                       
+                               }
+                               
+                               
+                               
+                               for (int i = 0; i < list.Count; i++)
+                                       yield return new KeyValuePair<long, T> (ind + i, list[i]);
+                               
+                               count *= partitionMultiplier;
+                       }
+               }                                  
+       }
+}
+#endif

diff --git a/mcs/class/corlib/System.Collections.Concurrent.Partitioners/ListPartitioner.cs b/mcs/class/corlib/System.Collections.Concurrent.Partitioners/ListPartitioner.cs
new file mode 100644 (file)
index 0000000..9d97565
--- /dev/null
+++ b/mcs/class/corlib/System.Collections.Concurrent.Partitioners/ListPartitioner.cs
@@ -0,0 +1,111 @@
+// 
+// ListPartitioner.cs
+//  
+// Author:
+//       Jérémie "Garuma" Laval <jeremie.laval@gmail.com>
+// 
+// Copyright (c) 2009 Jérémie "Garuma" Laval
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+
+#if NET_4_0 || BOOTSTRAP_NET_4_0
+
+namespace System.Collections.Concurrent.Partitioners
+{
+       // Represent a Range partitioner
+       internal class ListPartitioner<T> : OrderablePartitioner<T>
+       {
+               IList<T> source;
+               readonly bool chunking = Environment.GetEnvironmentVariable ("PLINQ_PARTITIONING_HINT") == "chunking";
+               
+               public ListPartitioner (IList<T> source) : base (true, true, true)
+               {
+                       this.source = source;
+               }
+               
+               public override IList<IEnumerator<KeyValuePair<long, T>>> GetOrderablePartitions (int partitionCount)
+               {
+                       if (partitionCount <= 0)
+                               throw new ArgumentOutOfRangeException ("partitionCount");
+                       
+                       IEnumerator<KeyValuePair<long, T>>[] enumerators
+                               = new IEnumerator<KeyValuePair<long, T>>[partitionCount];
+                       
+                       int count = source.Count / partitionCount;
+                       if (count <= 1)
+                               count = 1;
+                       
+                       for (int i = 0; i < enumerators.Length; i++) {
+                               if (chunking) {
+                                       const int step = 64;
+                                       enumerators[i] = GetEnumeratorForRange (i * step, enumerators.Length, source.Count, step);
+                                       continue;
+                               }
+                               
+                               if (i != enumerators.Length - 1)
+                                       enumerators[i] = GetEnumeratorForRange (i * count, i * count + count);
+                               else
+                                       enumerators[i] = GetEnumeratorForRange (i * count, source.Count);
+                       }
+                       
+                       return enumerators;
+               }
+               
+               IEnumerator<KeyValuePair<long, T>> GetEnumeratorForRange (int startIndex, int lastIndex)
+               {
+                       if (startIndex >= source.Count)
+                         return GetEmpty ();
+                       
+                       return GetEnumeratorForRangeInternal (startIndex, lastIndex);
+               }
+               
+               IEnumerator<KeyValuePair<long, T>> GetEnumeratorForRange (int startIndex, int stride, int count, int step)
+               {
+                       if (startIndex >= source.Count)
+                         return GetEmpty ();
+                       
+                       return GetEnumeratorForRangeInternal (startIndex, stride, count, step);
+               }
+
+               IEnumerator<KeyValuePair<long, T>> GetEmpty ()
+               {
+                       yield break;
+               }
+               
+               IEnumerator<KeyValuePair<long, T>> GetEnumeratorForRangeInternal (int startIndex, int lastIndex)
+               {       
+                       for (int i = startIndex; i < lastIndex; i++) {
+                               yield return new KeyValuePair<long, T> (i, source[i]);
+                       }
+               }
+               
+               IEnumerator<KeyValuePair<long, T>> GetEnumeratorForRangeInternal (int startIndex, int stride, int count, int step)
+               {
+                       for (int i = startIndex; i < count; i += stride * step) {
+                               for (int j = i; j < i + step && j < count; j++) {
+                                       yield return new KeyValuePair<long, T> (j, source[j]);
+                               }
+                       }
+               }
+       }
+}
+#endif

diff --git a/mcs/class/corlib/System.Collections.Concurrent.Partitioners/UserRangePartitioner.cs b/mcs/class/corlib/System.Collections.Concurrent.Partitioners/UserRangePartitioner.cs
new file mode 100644 (file)
index 0000000..eaec8b9
--- /dev/null
+++ b/mcs/class/corlib/System.Collections.Concurrent.Partitioners/UserRangePartitioner.cs
@@ -0,0 +1,123 @@
+// 
+// UserRangePartitioner.cs
+//  
+// Author:
+//       Jérémie "Garuma" Laval <jeremie.laval@gmail.com>
+// 
+// Copyright (c) 2010 Jérémie "Garuma" Laval
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+
+#if NET_4_0 || BOOTSTRAP_NET_4_0
+
+namespace System.Collections.Concurrent.Partitioners
+{
+       internal class UserRangePartitioner : OrderablePartitioner<Tuple<int,  int>>
+       {
+               readonly int start;
+               readonly int end;
+               readonly int rangeSize;
+
+               public UserRangePartitioner (int start, int end, int rangeSize) : base (true, true, true)
+               {
+                       this.start = start;
+                       this.end = end;
+                       this.rangeSize = rangeSize;
+               }
+               
+               public override IList<IEnumerator<KeyValuePair<long, Tuple<int, int>>>> GetOrderablePartitions (int partitionCount)
+               {
+                       if (partitionCount <= 0)
+                               throw new ArgumentOutOfRangeException ("partitionCount");
+                       
+                       var enumerators = new IEnumerator<KeyValuePair<long, Tuple<int, int>>>[partitionCount];
+                       for (int i = 1; i < partitionCount; i++)
+                               enumerators[i] = GetEmpty ();
+                       
+                       enumerators[0] = GetEnumerator ();
+
+                       return enumerators;
+               }
+               
+               IEnumerator<KeyValuePair<long, Tuple<int, int>>> GetEnumerator ()
+               {
+                       int sliceStart = start;
+                       long index = -1;
+                       
+                       while (sliceStart <= end) {
+                               yield return new KeyValuePair<long, Tuple<int, int>> (++index, Tuple.Create (sliceStart, Math.Min (end, sliceStart + rangeSize)));
+                               sliceStart += rangeSize;
+                       }
+               }
+
+               IEnumerator<KeyValuePair<long, Tuple<int, int>>> GetEmpty ()
+               {
+                       yield break;
+               }               
+       }
+
+       internal class UserLongRangePartitioner : OrderablePartitioner<Tuple<long,  long>>
+       {
+               readonly long start;
+               readonly long end;
+               readonly long rangeSize;
+
+               public UserLongRangePartitioner (long start, long end, long rangeSize) : base (true, true, true)
+               {
+                       this.start = start;
+                       this.end = end;
+                       this.rangeSize = rangeSize;
+               }
+               
+               public override IList<IEnumerator<KeyValuePair<long, Tuple<long, long>>>> GetOrderablePartitions (int partitionCount)
+               {
+                       if (partitionCount <= 0)
+                               throw new ArgumentOutOfRangeException ("partitionCount");
+                       
+                       var enumerators = new IEnumerator<KeyValuePair<long, Tuple<long, long>>>[partitionCount];
+                       for (int i = 1; i < partitionCount; i++)
+                               enumerators[i] = GetEmpty ();
+                       
+                       enumerators[0] = GetEnumerator ();
+
+                       return enumerators;
+               }
+               
+               IEnumerator<KeyValuePair<long, Tuple<long, long>>> GetEnumerator ()
+               {
+                       long sliceStart = start;
+                       long index = -1;
+                       
+                       while (sliceStart <= end) {
+                               yield return new KeyValuePair<long, Tuple<long, long>> (++index, Tuple.Create (sliceStart, Math.Min (end, sliceStart + rangeSize)));
+                               sliceStart += rangeSize;
+                       }
+               }
+
+               IEnumerator<KeyValuePair<long, Tuple<long, long>>> GetEmpty ()
+               {
+                       yield break;
+               }               
+       }
+
+}
+#endif

diff --git a/mcs/class/corlib/System.Collections.Concurrent/Partitioner.cs b/mcs/class/corlib/System.Collections.Concurrent/Partitioner.cs
index a3f17f2ead54893c8d89ee8eb88193e6e6df9b72..3521622f36360f043938b456e035b9ff773d8e27 100644 (file)
--- a/mcs/class/corlib/System.Collections.Concurrent/Partitioner.cs
+++ b/mcs/class/corlib/System.Collections.Concurrent/Partitioner.cs
@@ -31,6 +31,8 @@ using System.Collections.Generic;
 
 namespace System.Collections.Concurrent
 {
+       using Partitioners;
+
        public static class Partitioner
        {
                public static OrderablePartitioner<TSource> Create<TSource> (IEnumerable<TSource> source)

diff --git a/mcs/class/corlib/System.Collections.Concurrent/Partitioners/ChangeLog b/mcs/class/corlib/System.Collections.Concurrent/Partitioners/ChangeLog
deleted file mode 100644 (file)
index 12789a4..0000000
--- a/mcs/class/corlib/System.Collections.Concurrent/Partitioners/ChangeLog
+++ /dev/null
@@ -1,8 +0,0 @@
-2010-04-15  Jérémie Laval  <jeremie.laval@gmail.com>
-
-       * ListPartitioner.cs: Remove playground code
-
-2010-04-15  Jérémie Laval  <jeremie.laval@gmail.com>
-
-       * ListPartitioner.cs:
-       * EnumerablePartitioner.cs: Add internal behavior specific to PLinq

diff --git a/mcs/class/corlib/System.Collections.Concurrent/Partitioners/EnumerablePartitioner.cs b/mcs/class/corlib/System.Collections.Concurrent/Partitioners/EnumerablePartitioner.cs
deleted file mode 100644 (file)
index 23df7f7..0000000
--- a/mcs/class/corlib/System.Collections.Concurrent/Partitioners/EnumerablePartitioner.cs
+++ /dev/null
@@ -1,116 +0,0 @@
-// 
-// EnumerablePartitioner.cs
-//  
-// Author:
-//       Jérémie "Garuma" Laval <jeremie.laval@gmail.com>
-// 
-// Copyright (c) 2009 Jérémie "Garuma" Laval
-// 
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// 
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#if NET_4_0 || BOOTSTRAP_NET_4_0
-
-using System;
-using System.Threading.Tasks;
-using System.Collections.Generic;
-
-namespace System.Collections.Concurrent
-{
-       // Represent a chunk partitioner
-       internal class EnumerablePartitioner<T> : OrderablePartitioner<T>
-       {
-               IEnumerable<T> source;
-               
-               const int InitialPartitionSize = 1;
-               const int PartitionMultiplier = 2;
-               
-               int initialPartitionSize;
-               int partitionMultiplier;
-               
-               int index = 0;
-               readonly object syncLock = new object ();
-               
-               public EnumerablePartitioner (IEnumerable<T> source)
-                       : this (source, InitialPartitionSize, PartitionMultiplier)
-               {
-
-               }
-               
-               // This is used to get striped partitionning (for Take and Skip for instance
-               public EnumerablePartitioner (IEnumerable<T> source, int initialPartitionSize, int partitionMultiplier)
-                        : base (true, false, true)
-               {
-                       this.source = source;
-                       this.initialPartitionSize = initialPartitionSize;
-                       this.partitionMultiplier = partitionMultiplier;
-               }
-               
-               public override IList<IEnumerator<KeyValuePair<long, T>>> GetOrderablePartitions (int partitionCount)
-               {
-                       if (partitionCount <= 0)
-                               throw new ArgumentOutOfRangeException ("partitionCount");
-                       
-                       IEnumerator<KeyValuePair<long, T>>[] enumerators
-                               = new IEnumerator<KeyValuePair<long, T>>[partitionCount];
-                       
-                       IEnumerator<T> src = source.GetEnumerator ();
-                       
-                       for (int i = 0; i < enumerators.Length; i++) {
-                               enumerators[i] = GetPartitionEnumerator (src);
-                       }
-                       
-                       return enumerators;
-               }
-               
-               IEnumerator<KeyValuePair<long, T>> GetPartitionEnumerator (IEnumerator<T> src)
-               {
-                       int count = initialPartitionSize;
-                       List<T> list = new List<T> ();
-                       
-                       while (true) {
-                               list.Clear ();
-                               int ind = -1;
-                               
-                               lock (syncLock) {
-                                       ind = index;
-                                       
-                                       for (int i = 0; i < count; i++) {
-                                               if (!src.MoveNext ()) {
-                                                       if (list.Count == 0)
-                                                               yield break;
-                                                       else
-                                                               break;
-                                               }
-                                               
-                                               list.Add (src.Current);
-                                               index++;
-                                       }                                       
-                               }
-                               
-                               
-                               
-                               for (int i = 0; i < list.Count; i++)
-                                       yield return new KeyValuePair<long, T> (ind + i, list[i]);
-                               
-                               count *= partitionMultiplier;
-                       }
-               }                                  
-       }
-}
-#endif

diff --git a/mcs/class/corlib/System.Collections.Concurrent/Partitioners/ListPartitioner.cs b/mcs/class/corlib/System.Collections.Concurrent/Partitioners/ListPartitioner.cs
deleted file mode 100644 (file)
index 7512b37..0000000
--- a/mcs/class/corlib/System.Collections.Concurrent/Partitioners/ListPartitioner.cs
+++ /dev/null
@@ -1,111 +0,0 @@
-// 
-// ListPartitioner.cs
-//  
-// Author:
-//       Jérémie "Garuma" Laval <jeremie.laval@gmail.com>
-// 
-// Copyright (c) 2009 Jérémie "Garuma" Laval
-// 
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// 
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-using System;
-using System.Collections.Generic;
-
-#if NET_4_0 || BOOTSTRAP_NET_4_0
-
-namespace System.Collections.Concurrent
-{
-       // Represent a Range partitioner
-       internal class ListPartitioner<T> : OrderablePartitioner<T>
-       {
-               IList<T> source;
-               readonly bool chunking = Environment.GetEnvironmentVariable ("PLINQ_PARTITIONING_HINT") == "chunking";
-               
-               public ListPartitioner (IList<T> source) : base (true, true, true)
-               {
-                       this.source = source;
-               }
-               
-               public override IList<IEnumerator<KeyValuePair<long, T>>> GetOrderablePartitions (int partitionCount)
-               {
-                       if (partitionCount <= 0)
-                               throw new ArgumentOutOfRangeException ("partitionCount");
-                       
-                       IEnumerator<KeyValuePair<long, T>>[] enumerators
-                               = new IEnumerator<KeyValuePair<long, T>>[partitionCount];
-                       
-                       int count = source.Count / partitionCount;
-                       if (count <= 1)
-                               count = 1;
-                       
-                       for (int i = 0; i < enumerators.Length; i++) {
-                               if (chunking) {
-                                       const int step = 64;
-                                       enumerators[i] = GetEnumeratorForRange (i * step, enumerators.Length, source.Count, step);
-                                       continue;
-                               }
-                               
-                               if (i != enumerators.Length - 1)
-                                       enumerators[i] = GetEnumeratorForRange (i * count, i * count + count);
-                               else
-                                       enumerators[i] = GetEnumeratorForRange (i * count, source.Count);
-                       }
-                       
-                       return enumerators;
-               }
-               
-               IEnumerator<KeyValuePair<long, T>> GetEnumeratorForRange (int startIndex, int lastIndex)
-               {
-                       if (startIndex >= source.Count)
-                         return GetEmpty ();
-                       
-                       return GetEnumeratorForRangeInternal (startIndex, lastIndex);
-               }
-               
-               IEnumerator<KeyValuePair<long, T>> GetEnumeratorForRange (int startIndex, int stride, int count, int step)
-               {
-                       if (startIndex >= source.Count)
-                         return GetEmpty ();
-                       
-                       return GetEnumeratorForRangeInternal (startIndex, stride, count, step);
-               }
-
-               IEnumerator<KeyValuePair<long, T>> GetEmpty ()
-               {
-                       yield break;
-               }
-               
-               IEnumerator<KeyValuePair<long, T>> GetEnumeratorForRangeInternal (int startIndex, int lastIndex)
-               {       
-                       for (int i = startIndex; i < lastIndex; i++) {
-                               yield return new KeyValuePair<long, T> (i, source[i]);
-                       }
-               }
-               
-               IEnumerator<KeyValuePair<long, T>> GetEnumeratorForRangeInternal (int startIndex, int stride, int count, int step)
-               {
-                       for (int i = startIndex; i < count; i += stride * step) {
-                               for (int j = i; j < i + step && j < count; j++) {
-                                       yield return new KeyValuePair<long, T> (j, source[j]);
-                               }
-                       }
-               }
-       }
-}
-#endif

diff --git a/mcs/class/corlib/System.Collections.Concurrent/Partitioners/UserRangePartitioner.cs b/mcs/class/corlib/System.Collections.Concurrent/Partitioners/UserRangePartitioner.cs
deleted file mode 100644 (file)
index 7695eaa..0000000
--- a/mcs/class/corlib/System.Collections.Concurrent/Partitioners/UserRangePartitioner.cs
+++ /dev/null
@@ -1,123 +0,0 @@
-// 
-// UserRangePartitioner.cs
-//  
-// Author:
-//       Jérémie "Garuma" Laval <jeremie.laval@gmail.com>
-// 
-// Copyright (c) 2010 Jérémie "Garuma" Laval
-// 
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// 
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-using System;
-using System.Collections.Generic;
-
-#if NET_4_0 || BOOTSTRAP_NET_4_0
-
-namespace System.Collections.Concurrent
-{
-       internal class UserRangePartitioner : OrderablePartitioner<Tuple<int,  int>>
-       {
-               readonly int start;
-               readonly int end;
-               readonly int rangeSize;
-
-               public UserRangePartitioner (int start, int end, int rangeSize) : base (true, true, true)
-               {
-                       this.start = start;
-                       this.end = end;
-                       this.rangeSize = rangeSize;
-               }
-               
-               public override IList<IEnumerator<KeyValuePair<long, Tuple<int, int>>>> GetOrderablePartitions (int partitionCount)
-               {
-                       if (partitionCount <= 0)
-                               throw new ArgumentOutOfRangeException ("partitionCount");
-                       
-                       var enumerators = new IEnumerator<KeyValuePair<long, Tuple<int, int>>>[partitionCount];
-                       for (int i = 1; i < partitionCount; i++)
-                               enumerators[i] = GetEmpty ();
-                       
-                       enumerators[0] = GetEnumerator ();
-
-                       return enumerators;
-               }
-               
-               IEnumerator<KeyValuePair<long, Tuple<int, int>>> GetEnumerator ()
-               {
-                       int sliceStart = start;
-                       long index = -1;
-                       
-                       while (sliceStart <= end) {
-                               yield return new KeyValuePair<long, Tuple<int, int>> (++index, Tuple.Create (sliceStart, Math.Min (end, sliceStart + rangeSize)));
-                               sliceStart += rangeSize;
-                       }
-               }
-
-               IEnumerator<KeyValuePair<long, Tuple<int, int>>> GetEmpty ()
-               {
-                       yield break;
-               }               
-       }
-
-       internal class UserLongRangePartitioner : OrderablePartitioner<Tuple<long,  long>>
-       {
-               readonly long start;
-               readonly long end;
-               readonly long rangeSize;
-
-               public UserLongRangePartitioner (long start, long end, long rangeSize) : base (true, true, true)
-               {
-                       this.start = start;
-                       this.end = end;
-                       this.rangeSize = rangeSize;
-               }
-               
-               public override IList<IEnumerator<KeyValuePair<long, Tuple<long, long>>>> GetOrderablePartitions (int partitionCount)
-               {
-                       if (partitionCount <= 0)
-                               throw new ArgumentOutOfRangeException ("partitionCount");
-                       
-                       var enumerators = new IEnumerator<KeyValuePair<long, Tuple<long, long>>>[partitionCount];
-                       for (int i = 1; i < partitionCount; i++)
-                               enumerators[i] = GetEmpty ();
-                       
-                       enumerators[0] = GetEnumerator ();
-
-                       return enumerators;
-               }
-               
-               IEnumerator<KeyValuePair<long, Tuple<long, long>>> GetEnumerator ()
-               {
-                       long sliceStart = start;
-                       long index = -1;
-                       
-                       while (sliceStart <= end) {
-                               yield return new KeyValuePair<long, Tuple<long, long>> (++index, Tuple.Create (sliceStart, Math.Min (end, sliceStart + rangeSize)));
-                               sliceStart += rangeSize;
-                       }
-               }
-
-               IEnumerator<KeyValuePair<long, Tuple<long, long>>> GetEmpty ()
-               {
-                       yield break;
-               }               
-       }
-
-}
-#endif

diff --git a/mcs/class/corlib/corlib.dll.sources b/mcs/class/corlib/corlib.dll.sources
index 095e59633c3115d504dd22c41d10a6d6d223e48f..934358f0312e5452493c774ea50f6bc8d205af13 100644 (file)
--- a/mcs/class/corlib/corlib.dll.sources
+++ b/mcs/class/corlib/corlib.dll.sources
@@ -1542,9 +1542,9 @@ System.Collections.Concurrent/ConcurrentDictionary.cs
 System.Collections.Concurrent/Partitioner.cs
 System.Collections.Concurrent/ConcurrentQueue.cs
 System.Collections.Concurrent/ConcurrentSkipList.cs
-System.Collections.Concurrent/Partitioners/ListPartitioner.cs
-System.Collections.Concurrent/Partitioners/EnumerablePartitioner.cs
-System.Collections.Concurrent/Partitioners/UserRangePartitioner.cs
+System.Collections.Concurrent.Partitioners/ListPartitioner.cs
+System.Collections.Concurrent.Partitioners/EnumerablePartitioner.cs
+System.Collections.Concurrent.Partitioners/UserRangePartitioner.cs
 System.Collections.Concurrent/IProducerConsumerCollection.cs
 System.Collections.Concurrent/ConcurrentStack.cs
 System.Collections.Concurrent/SplitOrderedList.cs