Question

我已将boost的一部分 - ibeta_inv函数 - 编译成.Net 64位程序集，并且它工作得很好，直到我开始从多个线程调用它。然后它在某种程度上会返回错误的结果。

我使用此代码（C ++ / CLI）编写了它：

// Boost.h

#pragma once

#include <boost/math/special_functions/beta.hpp>

using namespace boost::math;

namespace Boost {

    public ref class BoostMath
    {
    public:
        double static InverseIncompleteBeta( double a, double b, double x )
        {
            return ibeta_inv(a,b,x);
        }
    };
}

以前有人试过吗？

我没有在.Net之外尝试过这个，所以我不知道这是不是原因，但我真的不明白为什么，因为它的单线程很好。

用法（C＃）：

private void calcBoost(List<Val> vals)
{
    //gives WRONG results (sometimes):
    vals.AsParallel().ForAll(v => v.BoostResult = BoostMath.InverseIncompleteBeta(v.A, v.B, v.X));
    //gives CORRECT results:
    vals.ForEach(v => v.BoostResult = BoostMath.InverseIncompleteBeta(v.A, v.B, v.X));
}

更新：从下面的评论中可以看出 - 我完全不确定这是一个Boost问题。也许这是一些奇怪的PLinq到C ++ / CLI的bug？我被废除了，以后会回来更多的事实。

Answer 1

Val类必须是线程安全的。

确保这一点的一个简单方法是使其不可变，但我发现你还需要编写BoostResult。所以这需要volatile，或者有某种形式的锁定。

public sealed class Val
{
    // Immutable fields are inheriently threadsafe 
    public readonly double A;
    public readonly double B;
    public readonly double X;

    // volatile is an easy way to make a single field thread safe
    // box and unbox to allow double as volatile
    private volatile object boostResult = 0.0;

    public Val(double A, double B, double X)
    {
        this.A = A;
        this.B = B;
        this.X = X;
    }

    public double BoostResult
    {
        get
        {
            return (double)boostResult;
        }
        set
        {
            boostResult = value;
        }
    }
}

锁定版本:(请参阅this question以确定哪种版本最适合您的应用）

public sealed class Val
{
    public readonly double A;
    public readonly double B;
    public readonly double X;

    private readonly object lockObject = new object();
    private double boostResult;

    public Val(double A, double B, double X)
    {
        this.A = A;
        this.B = B;
        this.X = X;
    }

    public double BoostResult
    {
        get
        {
            lock (lockObject)
            {
                return boostResult;
            }
        }
        set
        {
            lock (lockObject)
            {
                boostResult = value;
            }
        }
    }
}

如果您认为600万次锁定速度很慢，那么试试这个：

using System;

namespace ConsoleApplication17
{
    class Program
    {
        static void Main(string[] args)
        {
            { //without locks
                var startTime = DateTime.Now;
                int i2=0;
                for (int i = 0; i < 6000000; i++)
                {
                    i2++;
                }
                Console.WriteLine(i2);
                Console.WriteLine(DateTime.Now.Subtract(startTime)); //0.01 seconds on my machine
            }
            { //with locks
                var startTime = DateTime.Now;
                var obj = new Object();
                int i2=0;
                for (int i = 0; i < 6000000; i++)
                {
                    lock (obj)
                    {
                        i2++;
                    }
                }
                Console.WriteLine(i2);
                Console.WriteLine(DateTime.Now.Subtract(startTime)); //0.14 seconds on my machine, and this isn't even in parallel.
            }
            Console.ReadLine();
        }
    }
}

Answer 2

我碰巧在C ++ / CLI 64位项目中封装了boost的一部分，并且完全像你一样在C＃中使用它。

所以我在自己的Boost包装器中插入了C ++类，并将此代码添加到C＃项目中：

    private class Val
    {
        public double A;
        public double B;
        public double X;
        public double ParallellResult;
    }

    private static void findParallelError()
    {
        var r = new Random();

        while (true)
        {
            var vals = new List<Val>();
            for (var i = 0; i < 1000*1000; i++)
            {
                var val = new Val();
                val.A = r.NextDouble()*100;
                val.B = val.A + r.NextDouble()*1000;
                val.X = r.NextDouble();
                vals.Add(val);
            }

            // parallel calculation
            vals.AsParallel().ForAll(v => v.ParallellResult = Boost.BoostMath.InverseIncompleteBeta(v.A, v.B, v.X));

            /sequential verification
            var error = vals.Exists(v => v.ParallellResult != Boost.BoostMath.InverseIncompleteBeta(v.A, v.B, v.X));
            if (error)
                return;
        }
    }

它只是执行“永远”。并行结果始终等于顺序结果。这里没有线程不安全......

我建议您下载Boost的新副本并将其包含在一个全新的项目中并尝试一下吗？

我还注意到你把结果称为“BoostResult”......并在评论中提到“我们当前的实施”。你究竟在比较你的结果是什么？你对“正确”的定义是什么？

提升数学（ibeta_inv函数）不是线程安全吗？

2 个答案: