Boost Mathematik (ibeta_inv Funktion) nicht thread sicher?

Question

Ich habe einen Teil von Boost - die ibeta_inv-Funktion - in eine .Net 64-Bit-Assembly kompiliert und es funktionierte großartig, bis ich anfing, es aus mehreren Threads aufzurufen. Dann gibt es gelegentlich falsche Ergebnisse zurück.

I erfüllt es mit diesem Code (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); 
     } 
    }; 
} 

Hat jemand schon einmal ausprobiert?

Ich habe nicht versucht, dies außerhalb .Net, so dass ich nicht weiß, ob dies die Ursache ist, aber ich sehe wirklich nicht warum, da es funktioniert super single threaded.

Verbrauch (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: Wie unten in meinen Kommentaren zu sehen - ich bin nicht sicher, überhaupt nicht mehr, dass dies ein Boost-Problem. Vielleicht ist es ein seltsamer PLinq zu C++/CLI Bug ??? Ich bin geblufft und werde später mit mehr Fakten zurückkehren.

Answer 1

Ich habe einen Teil der Boost in einem C++/CLI 64bit-Projekt gekapselt und benutze es genau wie du aus C#.

Also warf ich in C++ Klasse in meinem eigenen Boost-Wrapper und fügte diesen Code zu C# Projekt:

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

Und es führt nur "für immer". Die parallelen Ergebnisse sind zu jeder Zeit den sequentiellen Ergebnissen gleich. Keine Threadunsicherheit hier ...

Darf ich vorschlagen, dass Sie eine neue Kopie von Boost herunterladen und in ein komplett neues Projekt einbinden und das ausprobieren?

Ich merke auch, dass Sie Ihr Ergebnis "BoostResult" aufgerufen haben ... und erwähnen Sie in den Kommentaren etwas über "unsere aktuelle Implementierung". Was genau vergleichen Sie Ihr Ergebnis gegen? Was ist deine Definition von "korrekt"?

Answer 2

Es ist wichtig, dass die Val Klasse threadsafe ist.

Ein einfacher Weg, um sicherzustellen, dass es wäre, es unveränderlich zu machen, aber ich sehe, Sie haben auch BoostResult, die geschrieben werden müssen. Also muss das volatile sein, oder irgendeine Form der Verriegelung haben.

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

Lock-Version: (this question sehen, um zu bestimmen, welche für Ihre Anwendung am besten geeignet ist)

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

Und wenn Sie denken, 6.000.000 Schlösser langsam sein, versuchen Sie einfach dieses:

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