2

如何在下面显示的第三个循环中添加进度条？

实验证据表明，在以下三个循环中，第三个是最快的。最佳性能是线程数与 CPU 的逻辑处理器相同时。我认为这是由于减少了分配和释放线程资源所花费的时间。

这是生成噪声图的代码。有时处理时间足够长以至于需要进度条。

        for (int j = 0; j < data.Length; j++)
        {
            var x = (location.X + (j % width));
            var y = (location.Y + (j / width));
            Vector3 p = new Vector3(x, y, frame);
            p *= zoom;
            float val = noise.GetNoise(p);
            data[j] += val;
            min = Math.Min(min, val);
            max = Math.Max(max, val);
        }

        Parallel.For(0, data.Length, (i) => {
            var x = (location.X + (i % width));
            var y = (location.Y + (i / width));
            Vector3 p = new Vector3(x, y, frame);
            p *= zoom;
            float val = noise.GetNoise(p);
            data[i] += val;
            min = Math.Min(min, val);
            max = Math.Max(max, val);
        });


        Parallel.For(0, threads, (i) =>
        {
            int from = i * data.Length / threads;
            int to = from + data.Length / threads;
            if (i == threads - 1) to = data.Length - 1;
            for (int j = from; j < to; j++)
            {
                var x = (location.X + (j % width));
                var y = (location.Y + (j / width));
                Vector3 p = new Vector3(x, y, frame);
                p *= zoom;
                float val = noise.GetNoise(p);
                data[j] += val;
                min = Math.Min(min, val);
                max = Math.Max(max, val);
            }
        }
        );

将更新速率限制为每秒几次的进度条是最好的。

添加 IProgress 我已经到了这里，这几乎可以工作。问题是在 parallel.for 完全完成后进度条会更新。

    private async Task<int> FillDataParallelAsync(int threads, IProgress<int> progress)
    {
        int precent = 0;
        /// parallel loop - easy and fast.
        Parallel.For(0, threads, (i) =>
        {
            int from = i * data.Length / threads;
            int to = from + data.Length / threads;
            if (i == threads - 1) to = data.Length - 1;
            for (int j = from; j < to; j++)
            {
                var x = (location.X + (j % width));
                var y = (location.Y + (j / width));
                Vector3 p = new Vector3(x, y, frame);
                p *= zoom;
                float val = noise.GetNoise(p);
                data[j] += val;
                min = Math.Min(min, val);
                max = Math.Max(max, val);

                if(j%(data.Length / 100) ==0)
                {
                    if (progress != null)
                    {
                        progress.Report(precent);
                    }
                    Interlocked.Increment(ref precent);
                }
            }
        }
        );
        return 0;
    }

在研究了太久之后，它现在看起来像这样。

        private Boolean FillDataParallel3D(int threads, CancellationToken token, IProgress<int> progress)
    {
        int precent = 0;
        Vector3 imageCenter = location;
        imageCenter.X -= width / 2;
        imageCenter.Y -= height / 2;
        ParallelOptions options = new ParallelOptions { CancellationToken = token };
        /// parallel loop - easy and fast.
        try
        {
            ParallelLoopResult result =
            Parallel.For(0, threads, options, (i, loopState) =>
            {
                int from = i * data.Length / threads;
                int to = from + data.Length / threads;
                if (i == threads - 1) to = data.Length - 1;
                for (int j = from; j < to; j++)
                {
                    if (loopState.ShouldExitCurrentIteration) break;
                    Vector3 p = imageCenter;
                    p.X += (j % width);
                    p.Y += (j / width);
                    p *= zoom;
                    float val = noise.GetNoise(p);
                    data[j] += val;
                    min = Math.Min(min, val);
                    max = Math.Max(max, val);
                    if (j % (data.Length / 100) == 0)
                    {
                        try { if (progress != null) progress.Report(precent); }
                        catch { }
                        Interlocked.Increment(ref precent);
                    }
                }
            }
            );
            return result.IsCompleted;
        }
        catch { }
        return false;
    }

进度部分从每个线程递增到总共 100 次。它在更新进度条时仍有一些延迟，但似乎是不可避免的。例如，如果进度条在绘制 100 次更新的时间内增加了 100 倍，则进度似乎排队并在方法返回后继续进行。在调用该方法后将进度显示抑制一秒钟就足够了。只有当方法花费的时间太长以至于您想知道是否正在发生任何事情时，进度条才真正有用。

完整项目位于https://github.com/David-Marsh/Designer

4

2 回答 2

1

你可能想看看MSDN上的IProgress 。IProgress 是作为显示进度的标准方式引入的。此接口公开了一个 Report(T) 方法，异步任务调用该方法来报告进度。您在异步方法的签名中公开此接口，调用者必须提供一个实现此接口的对象。

编辑：

线程应报告的内容取决于您需要报告的细粒度。最简单的方法是在每次迭代后报告进度。我有意编写迭代，因为Parallel.For方法不一定在单独的线程上执行每个迭代。

您的进度（可能以百分比为单位）是所有线程共享的。因此，以百分比计算当前进度并调用 Report 方法很可能需要锁定。请注意，这会对性能产生一些影响。

至于计算当前进度，你知道你有多少次迭代。您可以计算一次迭代与整体工作的比较。在每次迭代的开始或结束时，您只需将差异添加到整体进度中。

这是一个可以帮助您解决问题的示例：

public void ParallelForProgressExample(IProgress<int> progress = null)
{
    int percent = 0;
    ...

    var result = Parallel.For(fromInclusive, toExclusive, (i, state) => 
    {
        // do your work

        lock (lockObject)
        {
            // caluclate percentage
            // ...

            // update progress
            progress?.Report(percent);

        }
    });
}

作为进度，您可以使用System.Progress类或自己实现 IProgress 接口。

于 2019-06-17T07:47:27.000 回答
0

这与主要问题（进度条）无关。我只想注意，.NET Framework 包含一个Partitioner类，因此无需手动对数据进行分区：

Parallel.ForEach(Partitioner.Create(0, data.Length), range =>
{
    for (int j = range.Item1; j < range.Item2; j++)
    {
        var x = (location.X + (j % width));
        var y = (location.Y + (j / width));
        Vector3 p = new Vector3(x, y, frame);
        p *= zoom;
        float val = noise.GetNoise(p);
        data[j] += val;
        min = Math.Min(min, val);
        max = Math.Max(max, val);
    }
});
于 2019-06-18T08:17:38.043 回答