【问题标题】:Parallel class does not provide any speed up并行类不提供任何加速
【发布时间】:2013-10-05 20:20:01
【问题描述】:

我正在尝试创建一种方法,该方法将过滤掉低于给定灰度阈值的所有像素(例如,下面的都是黑色,上面的都是白色)。该方法有效,但没有我认为的那么快。

我决定使用Parallel 类,但无论我设置MaxDegreeOfParallelism 什么,我都没有获得任何速度优势。我也在位图上执行了一些其他操作,并且操作的总时间,无论MaxDegreeOfParallelism 是什么,总是在 170 毫秒左右。在调试时,执行此过滤本身所需的时间大约需要 160 毫秒,因此我认为会有明显的总体差异。

我使用的是 i7 处理器,4 个物理内核,8 个逻辑内核。

代码:

Color black = System.Drawing.Color.FromArgb(0, 0, 0);
Color white = System.Drawing.Color.FromArgb(255, 255, 255);

int lowerBound = (int)((float)lowerBoundPercent * 255.0 / 100.0);
int upperBound = (int)((float)upperBoundPercent * 255.0 / 100.0);

int[][] border = new int[8][];
for (int i=0;i<8;i++)
{
    border[i] = new int[] { i*height/8, (i+1)*height/8-1};
}

Parallel.For(0, 8, new ParallelOptions { MaxDegreeOfParallelism = 8 }, i =>
    {
        for (int k = 0; k < width; k++)
        {
            for (int j = border[i][0]; j <= border[i][1]; j++)
            {
                Color pixelColor;
                int grayscaleValue;
                pixelColor = color[k][j];
                grayscaleValue = (pixelColor.R + pixelColor.G + pixelColor.B) / 3;
                if (grayscaleValue >= lowerBound && grayscaleValue <= upperBound)
                    color[k][j] = white;
                else
                    color[k][j] = black;
            }
        }
    });

color[][] 是 System.Drawing.Color 的锯齿状数组。

问题:这正常吗?如果没有,我该怎么做才能改变它?

编辑:

像素提取:

Color[][] color;
color = new Color[bitmap.Width][];
for (int i = 0; i < bitmap.Width; i++)
{
    color[i] = new Color[bitmap.Height];
    for (int j = 0; j < bitmap.Height; j++)
    {
        color[i][j] = bitmap.GetOriginalPixel(i, j);
    }
}

Bitmap 是我自己的类 Bitmap 的一个实例:

public class Bitmap
{
    System.Drawing.Bitmap processed;
    //...
    public Color GetOriginalPixel(int x, int y) { return processed.GetPixel(x, y); }
    //...
}

【问题讨论】:

  • 您是否要测试调试版本的性能?
  • 其实我就是这么做的。我将在发布版本中对其进行测试并报告。
  • 你的测量结果如何?
  • 如果将lowerBound 和upperBound 乘以3,则在计算grayscaleValue 时不需要除以3。
  • 我会考虑使用 LockBits 重写你的代码,你可能会得到很大的改进,如果是这样,写下新方法作为答案并接受它。

标签: c# parallel-processing


【解决方案1】:

要回答关于为什么并行方法没有更快的主要问题,Parralel.For 仅从一个线程开始,然后添加更多线程,因为它检测到更多线程可能有利于加快工作速度,请注意并行选项是 MaxDegreeOfParallelism 而不仅仅是 DegreeOfParallelism。很简单,没有足够的循环迭代来启动足够多的线程以使其有效,您需要减少每次迭代的工作量。

尝试通过循环宽度而不是高度的 8 块来为并行操作提供更多工作。

Color black = System.Drawing.Color.FromArgb(0, 0, 0);
Color white = System.Drawing.Color.FromArgb(255, 255, 255);

int lowerBound = (int)((float)lowerBoundPercent * 255.0 / 100.0) * 3;
int upperBound = (int)((float)upperBoundPercent * 255.0 / 100.0) * 3;

Parallel.For(0, width, k =>
    {
        for (int j = 0; j < height; j++)
        {
                Color pixelColor;
                int grayscaleValue;
                pixelColor = color[k][j];
                grayscaleValue = (pixelColor.R + pixelColor.G + pixelColor.B);
                if (grayscaleValue >= lowerBound && grayscaleValue <= upperBound)
                    color[k][j] = white;
                else
                    color[k][j] = black;
        }
    });

我不会同时处理宽度和高度,那么您可能会遇到相反的问题,即没有给每次迭代足够的工作。

我强烈建议你去下载并阅读Patterns for Parallel Programming,在讨论你应该给Parallel.For 做多少工作时,它就是这个确切的例子。查看从 C# 版本第 26 页底部开始的“非常小的循环体”和“Too fine-grained, Too corse-grained”反模式查看您遇到的确切问题。

另外我会考虑使用 LockBits 来读取和读取像素数据,而不是像我们在 cmets 中讨论的那样使用 GetPixel 和 SetPixel。

【讨论】:

  • @Lasooch 我很好奇你会得到什么样的时差,只需改变每个For循环的工作量。
  • 我明天会检查一下,这里已经很晚了,所以我收工了。代码仍然是无与伦比的,但只是更改为LockBits 方式使得每帧的时间从~165 ms 下降到~55 ms。太棒了!
  • @Lasooch 也可以随意发布 LockBits 版本作为答案,我不介意看到它。
【解决方案2】:

使用LockBits,我设法将每帧的时间从~165 ms 缩短到~55 ms。然后我继续做更多的研究,并将LockBits 与不安全上下文中的指针操作和 Parallel.For 循环结合起来。结果代码:

位图类:

public class Bitmap
{
    System.Drawing.Bitmap processed;
    public System.Drawing.Bitmap Processed { get { return processed; } set { processed = value; } }
    // ...
}    

方法:

int lowerBound = 3*(int)((float)lowerBoundPercent * 255.0 / 100.0);
int upperBound = 3*(int)((float)upperBoundPercent * 255.0 / 100.0);

System.Drawing.Bitmap bp = bitmap.Processed;

int width = bitmap.Width;
int height = bitmap.Height;

Rectangle rect = new Rectangle(0, 0, width, height);
System.Drawing.Imaging.BitmapData bpData = bp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bp.PixelFormat);

unsafe
{
    byte* s0 = (byte*)bpData.Scan0.ToPointer();
    int stride = bpData.Stride;

    Parallel.For(0, height, y1 =>
    {
        int posY = y1 * stride;
        byte* cpp = s0 + posY;

        for (int x =0; x<width; x++)
        {
            int total = cpp[0] + cpp[1] + cpp[2];
            if (total >= lowerBound && total <= upperBound)
            {
                cpp[0] = 255;
                cpp[1] = 255;
                cpp[2] = 255;
                cpp[3] = 255;
            }
            else
            {
                cpp[0] = 0;
                cpp[1] = 0;
                cpp[2] = 0;
                cpp[3] = 255;
            }

            cpp += 4;
        }
    });
}

bp.UnlockBits(bpData);

通过Parallel.For 循环中的这种工作划分,代码在 1-5 毫秒内执行,这意味着大约加快了 70 倍!

我尝试将循环的块放大 4 倍和 8 倍,时间范围仍然是 1-5 毫秒,所以我不会讨论这个。无论如何,循环已经足够快了。

非常感谢您的回答,Scott,并感谢大家对 cme​​ts 的投入。

【讨论】:

  • 感谢您发布完整的解决方案,我相信这个答案将来会帮助很多人(我知道我会用它作为例子来指出其他人问类似问题时)
  • @Scott Chamberlain 在这种情况下,我将链接对我有很大帮助的答案,以便那些人可以从这里找到它。我的解决方案的一部分实际上只是从那里复制粘贴:link
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2011-01-20
  • 2019-03-29
  • 2018-03-26
  • 1970-01-01
  • 1970-01-01
  • 2012-07-18
相关资源
最近更新 更多