Question

我试图编写一个并行算法比基本相同的顺序算法快三倍。请参阅pastebin。

的粘贴 的

大家好。我正在为课堂做作业并完成了大部分工作，但是我在数学方面遇到了一些问题。我正在尝试计算表达式：

100000000
∑ (9999999/10000000)^i * i^2
i = 1

我从1到1000万。给出了一种快速顺序算法：

  double sum = 0.0;
  double fact1 = 0.9999999;
  for (int i = 1; i <= 10000000; i++)
  {
     sum += (fact1 * i * i);
     fact1 *= 0.9999999;
  }

我们应该实现它并验证它是否有效，以及它在发布模式下的时间。我已经完成并正常工作了。然后，时间显示在控制台上。

 DateTime t = DateTime.Now;
 long saveticks = t.Ticks;

 double sum = 0.0;
 double fact1 = 0.9999999;
 for (int i = 1; i <= 100000000; i++)
 {
    sum += (fact1 * i * i);
    fact1 *= 0.9999999;
 }

 t = DateTime.Now;

然后我们必须编写一个能够超越时间的定时并行算法，并且应该在示例并行程序之后对其进行建模。它必须至少比顺序算法快3倍。我们将为并行程序使用4个处理元素。

有一个提示，“在你弄清楚每个处理元素将要做的工作之后，你可能需要用耗时的Pow功能开始处理元素”。

例如： Math.Pow（X，Y）

“不要在每次迭代时对并行代码使用pow函数，因为它不会打败时间。”

这是我的并行程序代码。这既可以进行顺序算法，也可以进行并行算法，并对它们进行计时。

 const int numPEs = 4;
 const int size = 100000000;
 static double pSum;
 static int numThreadsDone;
 static int nextid;
 static object locker1 = new object();
 static object locker2 = new object();
 static long psaveticks;
 static DateTime pt;

 static void Main(string[] args)
 {
     DateTime t = DateTime.Now;
     long saveticks = t.Ticks;

     double sum = 0.0;
     double fact1 = 0.9999999;
     for (int i = 1; i <= 100000000; i++)
     {
         sum += (fact1 * (i * i));
         fact1 *= 0.9999999;
     }

     t = DateTime.Now;
     Console.WriteLine("sequential: " + ((t.Ticks - saveticks) / 100000000.0) + " seconds");
     Console.WriteLine("sum is " + sum);

     // time it
     pt = DateTime.Now;
     psaveticks = pt.Ticks;
     for (int i = 0; i < numPEs; i++)
     new Thread(countThreads).Start();

     Console.ReadKey();
 }



 static void countThreads()
 {
     int id;
     double localcount = 0;
     lock (locker1)
     {
         id = nextid;
         nextid++;
     }
     // assumes array is evenly divisible by the number of threads
     int granularity = size / numPEs;
     int start = granularity * id;

     for (int i = start; i < start + granularity; i++)
         localcount += (Math.Pow(0.9999999, i) * (i * i));

     lock (locker2)
     {
         pSum += localcount;
         numThreadsDone++;
         if (numThreadsDone == numPEs)
         {
             pt = DateTime.Now;
             Console.WriteLine("parallel: " + ((pt.Ticks - psaveticks) / 10000000.0) + " seconds");
             Console.WriteLine("parallel count is " + pSum);
         }
     }
 }

我的问题是我的顺序程序比并行程序快。我正在使用的算法存在问题。

有人可以帮忙吗？

Answer 1

Console.WriteLine("sequential: " + ((t.Ticks - saveticks) / 100000000.0) + " seconds");

一秒内有10,000,000个刻度。在上面的行中，您将除以额外的数量级100,000,000，使您的顺序执行看起来比实际快10倍。要避免这些错误，请使用.NET Framework本身的相应字段;在这种情况下，TimeSpan.TicksPerSecond。

你变慢的主要原因是你的并行代码比顺序代码的计算要求更高。

// Inner loop of sequential code:
sum += (fact1 * (i * i));
fact1 *= 0.9999999;

// Inner loop of parallel code:
localcount += (Math.Pow(0.9999999, i) * (i * i));

从数学的角度来看，你有理由假设取幂等同于重复乘法。但是，从计算的角度来看，Math.Pow操作比简单的乘法要昂贵得多。

减轻这些昂贵的Math.Pow调用的一种方法是在每个线程的开头只执行一次取幂，然后恢复使用普通乘法（就像你的顺序情况一样）：

double fact1 = Math.Pow(0.9999999, start + 1);
for (int i = start + 1; i <= start + granularity; i++)
{
    localcount += (fact1 * (i * i));
    fact1 *= 0.9999999;
}

在英特尔酷睿i7上，这为您的问题规模提供了大约3倍的加速。

强制性提醒：

请勿使用DateTime.Now来衡量短暂的时间间隔。请改用Stopwatch课程。
不要进行跨线程时间测量。等待你的工作线程从主线程完成，并从那里读取最终读数。

并行程序的求和算法

1 个答案: