一、谁能把这个程序的性能提升一倍？---并行排序算法
http://www.cnblogs.com/onlytiancai/archive/2009/04/21/1440829.html
如下，一组4元矢量的排序，如何把排序时间缩减一半？可以用并行算法。
using System;
using System.Collections.Generic;
using System.Diagnostics;
namespace Vector4Test
{
public class Vector
{
public double W;
public double X;
public double Y;
public double Z;
public double T;
}
internal class VectorComparer : IComparer<Vector>
{
public int Compare(Vector c1, Vector c2)
{
if (c1 == null || c2 == null)
throw new ArgumentNullException("Both objects must not be null");
double x = Math.Sqrt(Math.Pow(c1.X, 2)
+ Math.Pow(c1.Y, 2)
+ Math.Pow(c1.Z, 2)
+ Math.Pow(c1.W, 2));
double y = Math.Sqrt(Math.Pow(c2.X, 2)
+ Math.Pow(c2.Y, 2)
+ Math.Pow(c2.Z, 2)
+ Math.Pow(c2.W, 2));
if (x > y)
return 1;
else if (x < y)
return -1;
else
return 0;
}
}
internal class VectorComparer2 : IComparer<Vector> {
public int Compare(Vector c1, Vector c2) {
if (c1 == null || c2 == null)
throw new ArgumentNullException("Both objects must not be null");
if (c1.T > c2.T)
return 1;
else if (c1.T < c2.T)
return -1;
else
return 0;
}
}
internal class Program
{
private static void Main(string[] args)
{
Vector[] vectors = GetVectors();
var watch1 = new Stopwatch();
watch1.Start();
A(vectors);
watch1.Stop();
Console.WriteLine("A sort time: " + watch1.Elapsed);
vectors = GetVectors();
watch1.Reset();
watch1.Start();
B(vectors);
watch1.Stop();
Console.WriteLine("B sort time: " + watch1.Elapsed);
vectors = GetVectors();
watch1.Reset();
watch1.Start();
C(vectors);
watch1.Stop();
Console.WriteLine("C sort time: " + watch1.Elapsed);
Console.ReadKey();
}
private static Vector[] GetVectors()
{
int n = 1 << 15;
var vectors = new Vector[n];
var random = new Random();
for (int i = 0; i < n; i++)
{
vectors[i] = new Vector();
vectors[i].X = random.NextDouble();
vectors[i].Y = random.NextDouble();
vectors[i].Z = random.NextDouble();
vectors[i].W = random.NextDouble();
}
return vectors;
}
private static void A(Vector[] vectors)
{
Array.Sort(vectors, new VectorComparer());
}
private static void B(Vector[] vectors) {
int n = vectors.Length;
for (int i = 0; i < n; i++)
{
Vector c1 = vectors[i];
c1.T = Math.Sqrt(Math.Pow(c1.X, 2)
+ Math.Pow(c1.Y, 2)
+ Math.Pow(c1.Z, 2)
+ Math.Pow(c1.W, 2));
}
Array.Sort(vectors,new VectorComparer2());
}
private static void C(Vector[] vectors) {
int n = vectors.Length;
for (int i = 0; i < n; i++) {
Vector c1 = vectors[i];
c1.T = Math.Sqrt(c1.X * c1.X
+ c1.Y * c1.Y
+ c1.Z * c1.Z
+ c1.W * c1.W);
}
Array.Sort(vectors, new VectorComparer2());
}
}
}
我晕，刚开始我用的算法A，后来又写了个算法B，我还没用并行算法呢，一看B方法比A方法时间缩短了差不多两个数量级，如下
A sort time: 00:00:00.5346475
B sort time: 00:00:00.0169736
太奇怪了也，难道我的B算法二级缓存命中率比较高？谁能再把我的B方法消耗时间再降低一半，可以用任何语言，Vector类等也可以用自己的数据类型，比如结构啦，四维数组啥的，随意，只要是四元的矢量，每个分量是随机生成的，然后每个矢量的长度是根号下每个分量的平方和，满足这个条件就行。
modify by wawa at 2009-04-22 06:42
应大家回帖要求，
1、把随机数种子初始的语句放到了循环外面
2、每次执行排序重新获取新的乱序Vector
3、把B方法直接对计算出来的double[]排序换成了对对vector[]的排序，因为之前的代码实际上没有对vector[]排序
4、把Vector类增加了值T，用来保存该Vector的长度。
我这里结果如下
A sort time: 00:00:00.6661531
B sort time: 00:00:00.0423115
C sort time: 00:00:00.0302426
——————————————————————————————————————————————————————
————————————————————————————————————————————————————-————
二、并行排序算法
Author:Eaglet
今天早晨看到 蛙蛙池塘 的这篇博客 谁能把这个程序的性能提升一倍？---并行排序算法 。促使我写了一个并行排序算法，这个排序算法充分利用多核CPU进行并行计算，从而提高排序的效率。
先简单说一下蛙蛙池塘 给的A，B，C 三种算法（见上面引用的那篇博客），A算法将耗时的平方和开平方计算放到比较函数中，导致Array.Sort 时，每次亮亮比较都要执行平方和开平方计算，其平均算法复杂度为 O(nlog2n) 。 而B 将平方和开平方计算提取出来，算法复杂度降低到 O(n) ，这也就是为什么B比A效率要高很多的缘故。C 和 B 相比，将平方函数替换成了 x*x ，由于少了远程函数调用和Pow函数本身的开销，效率有提高了不少。我在C的基础上编写了D算法，D算法采用并行计算技术，在我的双核笔记本电脑上数据量比较大的情况下，其排序效率较C要提高30%左右。
下面重点介绍这个并行排序算法。算法思路其实很简单，就是将要排序的数组按照处理器数量等分成若干段，然后用和处理器数量等同的线程并行对各个小段进行排序，排序结束和，再在单一线程中对这若干个已经排序的小段进行归并排序，最后输出完整的排序结果。考虑到和.Net 2.0 兼容，我没有用微软提供的并行库，而是用多线程来实现。
下面是测试结果：
|
n |
A |
B |
C |
D |
|
32768 |
0.7345 |
0.04122 |
0.0216 |
0.0254 |
|
65535 |
1.5464 |
0.08863 |
0.05139 |
0.05149 |
|
131072 |
3.2706 |
0.1858 |
0.118 |
0.108 |
|
262144 |
6.8423 |
0.4056 |
0.29586 |
0.21849 |
|
524288 |
15.0342 |
0.9689 |
0.7318 |
0.4906 |
|
1048576 |
31.6312 |
1.9978 |
1.4646 |
1.074 |
|
2097152 |
66.9134 |
4.1763 |
3.0828 |
2.3095 |
从测试结果上看，当要排序的数组长度较短时，并行排序的效率甚至还没有不进行并行排序高，这主要是多线程的开销造成的。当数组长度增大到25万以上时，并行排序的优势开始体现出来，随着数组长度的增长，排序时间最后基本稳定在但线程排序时间的 74% 左右，其中并行排序的消耗大概在50%左右，归并排序的消耗在 14%左右。由此也可以推断，如果在4CPU的机器上，其排序时间最多可以减少到单线程的 14 + 25 = 39%。8 CPU 为 14 + 12.5 = 26.5%
目前这个算法在归并算法上可能还有提高的余地，如果哪位高手能够进一步提高这个算法，不妨贴出来一起交流交流。
下面分别给出并行排序和归并排序的代码：
并行排序类 ParallelSort
Paralletsort 类是一个通用的泛型，调用起来非常简单，下面给一个简单的int型数组的排序示例：
class IntComparer : IComparer<int>
{
IComparer Members
}
public void SortInt(int[] array)
{
Sort.ParallelSort<int> parallelSort = new Sort.ParallelSort<int>();
parallelSort.Sort(array, new IntComparer());
}
只要实现一个T类型两两比较的接口，然后调用ParallelSort 的 Sort 方法就可以了，是不是很简单？
下面是 ParallelSort类的代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace Sort
{
/// <summary>
/// ParallelSort
/// </summary>
/// <typeparam name="T"></typeparam>
public class ParallelSort<T>
{
enum Status
{
Idle = 0,
Running = 1,
Finish = 2,
}
class ParallelEntity
{
public Status Status;
public T[] Array;
public IComparer<T> Comparer;
public ParallelEntity(Status status, T[] array, IComparer<T> comparer)
{
Status = status;
Array = array;
Comparer = comparer;
}
}
private void ThreadProc(Object stateInfo)
{
ParallelEntity pe = stateInfo as ParallelEntity;
lock (pe)
{
pe.Status = ParallelSort<T>.Status.Running;
Array.Sort(pe.Array, pe.Comparer);
pe.Status = ParallelSort<T>.Status.Finish;
}
}
public void Sort(T[] array, IComparer<T> comparer)
{
//Calculate process count
int processorCount = Environment.ProcessorCount;
//If array.Length too short, do not use Parallel sort
if (processorCount == 1 || array.Length < processorCount)
{
Array.Sort(array, comparer);
return;
}
//Split array
ParallelEntity[] partArray = new ParallelEntity[processorCount];
int remain = array.Length;
int partLen = array.Length / processorCount;
//Copy data to splited array
for (int i = 0; i < processorCount; i++)
{
if (i == processorCount - 1)
{
partArray[i] = new ParallelEntity(Status.Idle, new T[remain], comparer);
}
else
{
partArray[i] = new ParallelEntity(Status.Idle, new T[partLen], comparer);
remain -= partLen;
}
Array.Copy(array, i * partLen, partArray[i].Array, 0, partArray[i].Array.Length);
}
//Parallel sort
for (int i = 0; i < processorCount - 1; i++)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc), partArray[i]);
}
ThreadProc(partArray[processorCount - 1]);
//Wait all threads finish
for (int i = 0; i < processorCount; i++)
{
while (true)
{
lock (partArray[i])
{
if (partArray[i].Status == ParallelSort<T>.Status.Finish)
{
break;
}
}
Thread.Sleep(0);
}
}
//Merge sort
MergeSort<T> mergeSort = new MergeSort<T>();
List<T[]> source = new List<T[]>(processorCount);
foreach (ParallelEntity pe in partArray)
{
source.Add(pe.Array);
}
mergeSort.Sort(array, source, comparer);
}
}
}
多路归并排序类 MergeSort
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Sort
{
/// <summary>
/// MergeSort
/// </summary>
/// <typeparam name="T"></typeparam>
public class MergeSort<T>
{
public void Sort(T[] destArray, List<T[]> source, IComparer<T> comparer)
{
//Merge Sort
int[] mergePoint = new int[source.Count];
for (int i = 0; i < source.Count; i++)
{
mergePoint[i] = 0;
}
int index = 0;
while (index < destArray.Length)
{
int min = -1;
for (int i = 0; i < source.Count; i++)
{
if (mergePoint[i] >= source[i].Length)
{
continue;
}
if (min < 0)
{
min = i;
}
else
{
if (comparer.Compare(source[i][mergePoint[i]], source[min][mergePoint[min]]) < 0)
{
min = i;
}
}
}
if (min < 0)
{
continue;
}
destArray[index++] = source[min][mergePoint[min]];
mergePoint[min]++;
}
}
}
}
主函数及测试代码 在蛙蛙池塘代码基础上修改
using System;
using System.Collections.Generic;
using System.Diagnostics;
namespace Vector4Test
{
public class Vector
{
public double W;
public double X;
public double Y;
public double Z;
public double T;
}
internal class VectorComparer : IComparer<Vector>
{
public int Compare(Vector c1, Vector c2)
{
if (c1 == null || c2 == null)
throw new ArgumentNullException("Both objects must not be null");
double x = Math.Sqrt(Math.Pow(c1.X, 2)
+ Math.Pow(c1.Y, 2)
+ Math.Pow(c1.Z, 2)
+ Math.Pow(c1.W, 2));
double y = Math.Sqrt(Math.Pow(c2.X, 2)
+ Math.Pow(c2.Y, 2)
+ Math.Pow(c2.Z, 2)
+ Math.Pow(c2.W, 2));
if (x > y)
return 1;
else if (x < y)
return -1;
else
return 0;
}
}
internal class VectorComparer2 : IComparer<Vector>
{
public int Compare(Vector c1, Vector c2)
{
if (c1 == null || c2 == null)
throw new ArgumentNullException("Both objects must not be null");
if (c1.T > c2.T)
return 1;
else if (c1.T < c2.T)
return -1;
else
return 0;
}
}
internal class Program
{
private static void Print(Vector[] vectors)
{
//foreach (Vector v in vectors)
//{
// Console.WriteLine(v.T);
//}
}
private static void Main(string[] args)
{
Vector[] vectors = GetVectors();
Console.WriteLine(string.Format("n = {0}", vectors.Length));
Stopwatch watch1 = new Stopwatch();
watch1.Start();
A(vectors);
watch1.Stop();
Console.WriteLine("A sort time: " + watch1.Elapsed);
Print(vectors);
vectors = GetVectors();
watch1.Reset();
watch1.Start();
B(vectors);
watch1.Stop();
Console.WriteLine("B sort time: " + watch1.Elapsed);
Print(vectors);
vectors = GetVectors();
watch1.Reset();
watch1.Start();
C(vectors);
watch1.Stop();
Console.WriteLine("C sort time: " + watch1.Elapsed);
Print(vectors);
vectors = GetVectors();
watch1.Reset();
watch1.Start();
D(vectors);
watch1.Stop();
Console.WriteLine("D sort time: " + watch1.Elapsed);
Print(vectors);
Console.ReadKey();
}
private static Vector[] GetVectors()
{
int n = 1 << 21;
Vector[] vectors = new Vector[n];
Random random = new Random();
for (int i = 0; i < n; i++)
{
vectors[i] = new Vector();
vectors[i].X = random.NextDouble();
vectors[i].Y = random.NextDouble();
vectors[i].Z = random.NextDouble();
vectors[i].W = random.NextDouble();
}
return vectors;
}
private static void A(Vector[] vectors)
{
Array.Sort(vectors, new VectorComparer());
}
private static void B(Vector[] vectors)
{
int n = vectors.Length;
for (int i = 0; i < n; i++)
{
Vector c1 = vectors[i];
c1.T = Math.Sqrt(Math.Pow(c1.X, 2)
+ Math.Pow(c1.Y, 2)
+ Math.Pow(c1.Z, 2)
+ Math.Pow(c1.W, 2));
}
Array.Sort(vectors, new VectorComparer2());
}
private static void C(Vector[] vectors)
{
int n = vectors.Length;
for (int i = 0; i < n; i++)
{
Vector c1 = vectors[i];
c1.T = Math.Sqrt(c1.X * c1.X
+ c1.Y * c1.Y
+ c1.Z * c1.Z
+ c1.W * c1.W);
}
Array.Sort(vectors, new VectorComparer2());
}
private static void D(Vector[] vectors)
{
int n = vectors.Length;
for (int i = 0; i < n; i++)
{
Vector c1 = vectors[i];
c1.T = Math.Sqrt(c1.X * c1.X
+ c1.Y * c1.Y
+ c1.Z * c1.Z
+ c1.W * c1.W);
}
Sort.ParallelSort<Vector> parallelSort = new Sort.ParallelSort<Vector>();
parallelSort.Sort(vectors, new VectorComparer2());
}
}
}