Boost數學（ibeta_inv函數）不是線程安全的？

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)); 
} 

UPDATE：可以看出在下面我的意見 - 我不知道在所有了，這是一個加速的問題。也許這是一些奇怪的PLinq到C++/CLI bug？我很忙，並且會在稍後回覆更多的事實。

Answer 1

我碰巧在C++/CLI 64bit項目中封裝了boost的一部分，並且完全按照您的方式在C＃中使用它。

所以，我在你的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; 
     } 
    } 

它只是執行「永遠」。平行結果始終等於順序結果。這裏沒有線程不安全的...

我可以建議你下載一個新的副本升壓並將其包含在一個全新的項目中，並嘗試一下嗎？

我還注意到，你稱你的結果爲「BoostResult」......並在評論中提到了有關「我們當前的實現」的內容。究竟是什麼你比較你的結果再次？你對「正確」的定義是什麼？

Answer 2

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(); 
     } 
    } 
}