Boost math (función ibeta_inv) ¿no es seguro para subprocesos?

Question

He compilado parte de boost - la función ibeta_inv - en un ensamblado .Net de 64 bits y funcionó muy bien hasta que comencé a llamarlo desde múltiples hilos. Luego, ocasionalmente devuelve resultados incorrectos.

Accedí que el uso de este código (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); 
     } 
    }; 
} 

Alguien ha probado esto antes?

No he probado esto fuera de .Net, así que no sé si esta es la causa, pero realmente no veo por qué, ya que funciona muy bien.

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

ACTUALIZACIÓN: Como se puede ver en mis comentarios a continuación - no estoy seguro en todos los más que se trata de un problema Boost. Tal vez es un error raro de PLinq a C++/CLI ??? Estoy descartado y volveré con más hechos más tarde.

Answer 1

Sucede que he encapsulado parte del impulso en un proyecto de C++/CLI de 64 bits y lo uso de C# exactamente como lo hace.

Así que me tiró en la clase de C++ en mi propio envoltorio Boost y añade este código al proyecto de 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; 
     } 
    } 

Y simplemente ejecuta "para siempre". Los resultados paralelos son iguales a los resultados secuenciales todo el tiempo. No hay hilo inseguridad aquí ...

¿Puedo sugerirle que descargue una copia nueva de Boost e incluirla en un proyecto completamente nuevo y probarlo?

También noté que llamó su resultado "BoostResult" ... y mencionó en los comentarios algo sobre "nuestra implementación actual". Exactamente, ¿qué estás comparando con tus resultados? ¿Cuál es su definición de "correcto"?

Answer 2

Es vital que la clase Val sea segura para los hilos.

Una manera simple de asegurar esto sería hacerlo inmutable, pero veo que también tiene que escribir BoostResult. Entonces eso tendrá que ser volatile, o tener alguna forma de bloqueo.

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

versión de bloqueo: (ver this question para determinar cuál es el más adecuado para su aplicación)

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

Y si usted piensa 6 millones de cerraduras serán lentos, sólo trata de esto:

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